deploygate 0.6.7 → 0.8.2

data/lib/deploygate/commands/add_devices.rb

@@ -21,22 +21,27 @@ module DeployGate
           distribution_key = options.distribution_key
           server           = options.server
 
-          bundle_id = bundle_id(work_dir, options.configuration)
+          root_path = DeployGate::Xcode::Ios.project_root_path(work_dir)
+          workspaces = DeployGate::Xcode::Ios.find_workspaces(root_path)
+          analyze = DeployGate::Xcode::Analyze.new(workspaces, options.configuration)
+          bundle_id = analyze.target_bundle_identifier
+          developer_team = analyze.developer_team
+          member_center = DeployGate::Xcode::MemberCenter.new(developer_team)
 
           if server
-            run_server(session, owner, bundle_id, distribution_key, args, options)
+            run_server(session, owner, bundle_id, distribution_key, member_center, args, options)
           else
-            device_register(session, owner, udid, device_name, bundle_id, args, options)
+            device_register(session, owner, udid, device_name, bundle_id, member_center, args, options)
           end
         end
 
-        def run_server(session, owner, bundle_id, distribution_key, args, options)
-          DeployGate::AddDevicesServer.new().start(session.token, owner, bundle_id, distribution_key, args, options)
+        def run_server(session, owner, bundle_id, distribution_key, member_center, args, options)
+          DeployGate::AddDevicesServer.new().start(session.token, owner, bundle_id, distribution_key, member_center, args, options)
         end
 
-        def device_register(session, owner, udid, device_name, bundle_id, args, options)
+        def device_register(session, owner, udid, device_name, bundle_id, member_center, args, options)
           if udid.nil? && device_name.nil?
-            devices = fetch_devices(session.token, owner, bundle_id)
+            devices = fetch_devices(session.token, owner, bundle_id, member_center)
             select_devices = select_devices(devices)
             not_device if select_devices.empty?
 
@@ -44,7 +49,7 @@ module DeployGate
           else
             register_udid = udid || HighLine.ask(I18n.t('commands.add_devices.input_udid'))
             register_device_name = device_name || HighLine.ask(I18n.t('commands.add_devices.input_device_name'))
-            device = DeployGate::Xcode::MemberCenters::Device.new(register_udid, '', register_device_name)
+            device = DeployGate::Xcode::MemberCenters::Device.new(register_udid, '', register_device_name, member_center)
 
             puts device.to_s
             if HighLine.agree(I18n.t('commands.add_devices.device_register_confirm')) {|q| q.default = "y"}
@@ -54,7 +59,7 @@ module DeployGate
             end
           end
 
-          build!(bundle_id, args, options)
+          build!(bundle_id, member_center, args, options)
         end
 
         def register!(devices)
@@ -64,18 +69,18 @@ module DeployGate
           end
         end
 
-        def build!(bundle_id, args, options)
-          app = DeployGate::Xcode::MemberCenters::App.new(bundle_id)
+        def build!(bundle_id, member_center, args, options)
+          app = DeployGate::Xcode::MemberCenters::App.new(bundle_id, member_center)
           app.create! unless app.created?
 
-          DeployGate::Xcode::MemberCenters::ProvisioningProfile.new(bundle_id).create!
-          team = DeployGate::Xcode::MemberCenter.instance.team
+          DeployGate::Xcode::MemberCenters::ProvisioningProfile.new(bundle_id, member_center).create!
+          team = member_center.team
           DeployGate::Xcode::Export.clean_provisioning_profiles(bundle_id, team)
 
           DeployGate::Commands::Deploy::Build.run(args, options)
         end
 
-        def fetch_devices(token, owner, bundle_id)
+        def fetch_devices(token, owner, bundle_id, member_center)
           res = DeployGate::API::V1::Users::App.not_provisioned_udids(token, owner, bundle_id)
           if res[:error]
             case res[:message]
@@ -89,21 +94,11 @@ module DeployGate
           end
 
           results = res[:results]
-          devices = results.map{|r| DeployGate::Xcode::MemberCenters::Device.new(r[:udid], r[:user_name], r[:device_name])}
+          devices = results.map{|r| DeployGate::Xcode::MemberCenters::Device.new(r[:udid], r[:user_name], r[:device_name], member_center)}
 
           devices
         end
 
-        # @param [String] work_dir
-        # @param [String] build_configuration
-        # @return [String]
-        def bundle_id(work_dir, build_configuration)
-          root_path = DeployGate::Xcode::Ios.project_root_path(work_dir)
-          workspaces = DeployGate::Xcode::Ios.find_workspaces(root_path)
-          analyze = DeployGate::Xcode::Analyze.new(workspaces, build_configuration)
-          analyze.target_bundle_identifier
-        end
-
         # @param [Array]
         # @return [Array]
         def select_devices(devices)

data/lib/deploygate/commands/deploy/build.rb

@@ -38,44 +38,24 @@ module DeployGate
             analyze = DeployGate::Xcode::Analyze.new(workspaces, build_configuration, target_scheme)
             target_scheme = analyze.scheme
 
-            # TODO: Support export method option (ex: --method adhoc)
-            codesigning_identity= nil
-            provisioning_style = analyze.provisioning_style
-            provisioning_profile_info = nil
-            if (!over_xcode?(8) && provisioning_style == nil) ||
-                provisioning_style == DeployGate::Xcode::Analyze::PROVISIONING_STYLE_MANUAL
-
-              # Only run Provisioning Style is Manual or nil
-              bundle_identifier = analyze.target_bundle_identifier
-              xcode_provisioning_profile_uuid = analyze.target_xcode_setting_provisioning_profile_uuid
-              provisioning_team = analyze.provisioning_team
-              target_provisioning_profile = DeployGate::Xcode::Export.provisioning_profile(
-                  bundle_identifier,
-                  xcode_provisioning_profile_uuid,
-                  provisioning_team
-              )
-
-              method = DeployGate::Xcode::Export.method(target_provisioning_profile)
-              codesigning_identity = DeployGate::Xcode::Export.codesigning_identity(target_provisioning_profile)
-
-              profile = FastlaneCore::ProvisioningProfile.parse(target_provisioning_profile)
-              provisioning_profile_info = {
-                  provisioningProfiles: {
-                      "#{bundle_identifier}" => profile['Name']
-                  }
-              }
-            else
-              method = select_method
+            code_sign_identity = nil
+            project_profile_info = nil
+            allow_provisioning_updates = true
+            if analyze.code_sign_style == Xcode::Analyze::PROVISIONING_STYLE_MANUAL
+              code_sign_identity = analyze.code_sign_identity
+              project_profile_info = analyze.project_profile_info
             end
 
+            method = Xcode::Export.method(analyze.target_provisioning_profile) || select_method
+
             ipa_path = DeployGate::Xcode::Ios.build(
                 analyze,
                 target_scheme,
-                codesigning_identity,
-                provisioning_profile_info,
+                code_sign_identity,
+                project_profile_info,
                 build_configuration,
                 method,
-                over_xcode?(9) && codesigning_identity.nil?
+                allow_provisioning_updates
             )
             Push.upload([ipa_path], options)
           end

data/lib/deploygate/deploy.rb

@@ -1,10 +1,10 @@
 module DeployGate
   class Deploy
-    class NotLoginError < DeployGate::NotIssueError
+    class NotLoginError < DeployGate::RavenIgnoreException
     end
-    class NotFileExistError < DeployGate::NotIssueError
+    class NotFileExistError < DeployGate::RavenIgnoreException
     end
-    class UploadError < DeployGate::NotIssueError
+    class UploadError < DeployGate::RavenIgnoreException
     end
 
     class << self

data/lib/deploygate/raven_ignore_exception.rb

@@ -0,0 +1,4 @@
+module DeployGate
+  class RavenIgnoreException < StandardError
+  end
+end

data/lib/deploygate/session.rb

@@ -1,6 +1,6 @@
 module DeployGate
   class Session
-    class LoginError < DeployGate::NotIssueError
+    class LoginError < DeployGate::RavenIgnoreException
     end
 
     attr_reader :name, :token

data/lib/deploygate/version.rb

@@ -1,3 +1,3 @@
 module DeployGate
-  VERSION = '0.6.7'
+  VERSION = '0.8.2'
 end

data/lib/deploygate/xcode/analyze.rb

@@ -1,7 +1,7 @@
 module DeployGate
   module Xcode
     class Analyze
-      attr_reader :workspaces, :scheme_workspace, :build_workspace, :scheme
+      attr_reader :workspaces, :scheme_workspace, :build_workspace, :scheme, :xcodeproj
 
       BASE_WORK_DIR_NAME = 'project.xcworkspace'
       DEFAULT_BUILD_CONFIGURATION = 'Release'
@@ -9,7 +9,7 @@ module DeployGate
       PROVISIONING_STYLE_AUTOMATIC = 'Automatic'
       PROVISIONING_STYLE_MANUAL    = 'Manual'
 
-      class BundleIdentifierDifferentError < DeployGate::NotIssueError
+      class BundleIdentifierDifferentError < DeployGate::RavenIgnoreException
       end
 
       # @param [Array] workspaces
@@ -23,153 +23,93 @@ module DeployGate
         @build_workspace = find_build_workspace(workspaces)
         @xcodeproj = File.dirname(@scheme_workspace)
 
-        config = FastlaneCore::Configuration.create(Gym::Options.available_options, { workspace: @scheme_workspace })
-        project = FastlaneCore::Project.new(config)
+        config = FastlaneCore::Configuration.create(Gym::Options.available_options, { project: @xcodeproj })
+        Gym.config = config
+        @project = FastlaneCore::Project.new(config)
 
-        if project.schemes.length > 1 && target_scheme && project.schemes.include?(target_scheme)
-          project.options[:scheme] = target_scheme
+        if @project.schemes.length > 1 && target_scheme && @project.schemes.include?(target_scheme)
+          @project.options[:scheme] = target_scheme
         else
-          project.select_scheme
+          @project.select_scheme
         end
-        @scheme = project.options[:scheme]
+        @scheme = @project.options[:scheme]
       end
 
-      # Support Xcode7 more
-      # @return [String]
-      def target_bundle_identifier
-        begin
-          product_name = target_product_name
-          product_bundle_identifier = target_build_configration.build_settings['PRODUCT_BUNDLE_IDENTIFIER']
-          product_bundle_identifier = convert_bundle_identifier(product_bundle_identifier)
-
-          info_plist_file_path = target_build_configration.build_settings['INFOPLIST_FILE']
-          root_path = DeployGate::Xcode::Ios.project_root_path(@scheme_workspace)
-          plist_bundle_identifier =
-              File.open(File.join(root_path, info_plist_file_path)) do |file|
-                plist = Plist.parse_xml file.read
-                plist['CFBundleIdentifier']
-              end
-          plist_bundle_identifier = convert_bundle_identifier(plist_bundle_identifier)
-
-          bundle_identifier = if plist_bundle_identifier.blank?
-                                product_bundle_identifier
-                              else
-                                plist_bundle_identifier
-                              end
-          bundle_identifier.gsub!(/\$\(PRODUCT_NAME:.+\)/, product_name)
-        rescue BundleIdentifierDifferentError => e
-          raise e
-        rescue => e
-          cli = HighLine.new
-          puts I18n.t('xcode.analyze.target_bundle_identifier.prompt')
-          bundle_identifier = cli.ask(I18n.t('xcode.analyze.target_bundle_identifier.ask')) { |q| q.validate = /^(\w+)\.(\w+).*\w$/ }
+      def code_sign_style
+        style = nil
+        resolve_build_configuration do |build_configuration, target|
+          style = build_configuration.resolve_build_setting("CODE_SIGN_STYLE", target)
         end
 
-        bundle_identifier
+        style
       end
 
-      # @param [String] bundle_identifier
-      # @return [String]
-      def convert_bundle_identifier(bundle_identifier)
-        new_bundle_identifier = bundle_identifier.gsub(/\$\(([^\)]+)\)|\${([^}]+)}/) {
-          custom_id = $1 || $2
-          if custom_id == 'TARGET_NAME'
-            target_project_setting.name
-          else
-            target_build_configration.build_settings[custom_id]
-          end
-        }
-        # bail out if the result identical to the original
-        return bundle_identifier if new_bundle_identifier == bundle_identifier
+      def code_sign_identity
+        identity = nil
+        resolve_build_configuration do |build_configuration, target|
+          identity = build_configuration.resolve_build_setting("CODE_SIGN_IDENTITY", target)
+        end
 
-        convert_bundle_identifier(new_bundle_identifier)
+        identity
       end
 
+      # TODO: Need to support UDID additions for watchOS and App Extension
       # @return [String]
-      def target_xcode_setting_provisioning_profile_uuid
-        uuid = target_build_configration.build_settings['PROVISIONING_PROFILE']
-        UUID.validate(uuid) ? uuid : nil
-      end
-
-      def provisioning_style
-        target = target_provisioning_info
-        build_settings = target_build_configration.build_settings
-
-        style = PROVISIONING_STYLE_MANUAL
-        if target
-          # Manual or Automatic or nil (Xcode7 below)
-          begin
-            style = target['ProvisioningStyle'] || build_settings['CODE_SIGN_STYLE']
-          rescue
-            # Not catch error
-          end
+      def target_bundle_identifier
+        bundle_identifier = nil
+        resolve_build_configuration do |build_configuration, target|
+          bundle_identifier = build_configuration.resolve_build_setting("PRODUCT_BUNDLE_IDENTIFIER", target)
         end
 
-        style
+        bundle_identifier
       end
 
-      def provisioning_team
-        target = target_provisioning_info
-
+      def developer_team
         team = nil
-        if target
-          begin
-            team = target['DevelopmentTeam']
-          rescue
-            # Not catch error
-          end
+        resolve_build_configuration do |build_configuration, target|
+          team = build_configuration.resolve_build_setting("DEVELOPMENT_TEAM", target)
         end
 
         team
       end
 
-      private
-
-      def target_provisioning_info
-        main_target = target_project_setting
-        main_target_uuid = main_target && main_target.uuid
-
-        target = nil
-        if main_target_uuid
-          begin
-            target = target_project.root_object.attributes['TargetAttributes'][main_target_uuid]
-          rescue
-            # Not catch error
-          end
-        end
+      def project_profile_info
+        gym = Gym::CodeSigningMapping.new(project: @project)
 
-        target
+        {
+            provisioningProfiles: gym.detect_project_profile_mapping
+        }
       end
 
-      def target_build_configration
-        target_project_setting.build_configuration_list.build_configurations.reject{|conf| conf.name != @build_configuration}.first
-      end
+      def target_provisioning_profile
+        gym = Gym::CodeSigningMapping.new(project: @project)
+        bundle_id = target_bundle_identifier
 
-      def target_product_name
-        target_project_setting.product_name
+        Xcode::Export.provisioning_profile(bundle_id, nil, developer_team, gym.merge_profile_mapping[bundle_id.to_sym])
       end
 
-      def target_project_setting
-        scheme_file = find_xcschemes
-        xs = Xcodeproj::XCScheme.new(scheme_file)
-        target_name = xs.profile_action.buildable_product_runnable.buildable_reference.target_name
+      private
 
-        target_project.native_targets.reject{|target| target.name != target_name}.first
-      end
+      def resolve_build_configuration(&block)
+        gym = Gym::CodeSigningMapping.new(project: @project)
+        specified_configuration = gym.detect_configuration_for_archive
 
-      def target_project
-        Xcodeproj::Project.open(@xcodeproj)
-      end
+        Xcodeproj::Project.open(@xcodeproj).targets.each do |target|
+          target.build_configuration_list.build_configurations.each do |build_configuration|
+            # Used the following code as an example
+            # https://github.com/fastlane/fastlane/blob/2.148.1/gym/lib/gym/code_signing_mapping.rb#L138
+            current = build_configuration.build_settings
+            next if gym.test_target?(current)
+            sdk_root = build_configuration.resolve_build_setting("SDKROOT", target)
+            next unless gym.same_platform?(sdk_root)
+            next unless specified_configuration == build_configuration.name
 
-      def find_xcschemes
-        shared_schemes = Dir[File.join(@xcodeproj, 'xcshareddata', 'xcschemes', '*.xcscheme')].reject do |scheme|
-          @scheme != File.basename(scheme, '.xcscheme')
-        end
-        user_schemes = Dir[File.join(@xcodeproj, 'xcuserdata', '*.xcuserdatad', 'xcschemes', '*.xcscheme')].reject do |scheme|
-          @scheme != File.basename(scheme, '.xcscheme')
-        end
+            # If SKIP_INSTALL is true, it is an app extension or watch app
+            next if current["SKIP_INSTALL"]
 
-        shared_schemes.concat(user_schemes).first
+            block.call(build_configuration, target)
+          end
+        end
       end
 
       # @param [Array] workspaces

data/lib/deploygate/xcode/export.rb

@@ -12,12 +12,12 @@ module DeployGate
         # @param [String] uuid
         # @param [String] provisioning_team
         # @return [String]
-        def provisioning_profile(bundle_identifier, uuid = nil, provisioning_team = nil)
-          local_teams = DeployGate::Xcode::Export.find_local_data(bundle_identifier, uuid, provisioning_team)
+        def provisioning_profile(bundle_identifier, uuid = nil, provisioning_team = nil, specifier_name = nil)
+          local_teams = DeployGate::Xcode::Export.find_local_data(bundle_identifier, uuid, provisioning_team, specifier_name)
 
           case local_teams.teams_count
             when 0
-              target_provisioning_profile = create_provisioning(bundle_identifier, uuid)
+              target_provisioning_profile = create_provisioning(bundle_identifier, uuid, provisioning_team)
             when 1
               target_provisioning_profile = select_profile(local_teams.first_team_profile_paths)
             else
@@ -32,12 +32,13 @@ module DeployGate
         # @param [String] uuid
         # @param [String] provisioning_team
         # @return [LocalTeams]
-        def find_local_data(bundle_identifier, uuid = nil, provisioning_team = nil)
+        def find_local_data(bundle_identifier, uuid = nil, provisioning_team = nil, specifier_name = nil)
           local_teams = LocalTeams.new
 
           profile_paths = load_profile_paths
           profiles = profile_paths.map{|p| profile_to_plist(p)}
           profiles.reject! {|profile| profile['UUID'] != uuid} unless uuid.nil?
+          profiles.reject! {|profile| profile['Name'] != specifier_name} unless specifier_name.nil?
 
           profiles.each do |profile|
             next if DateTime.now >= profile['ExpirationDate'] || !installed_certificate?(profile['Path'])
@@ -79,7 +80,7 @@ module DeployGate
           certificates = installed_certificates()
           ids = []
           certificates.each do |current|
-            next unless current.match(/iPhone Distribution:/)
+            next unless current.match(/iPhone Distribution:/) || current.match(/Apple Distribution:/)
             begin
               (ids << current.match(/.*\) (.*) \".*/)[1])
             rescue
@@ -91,12 +92,12 @@ module DeployGate
         end
 
         # @return [Array]
-        def installed_distribution_conflicting_certificates
+        def installed_distribution_conflicting_certificates_by(distribution_name)
           certificates = installed_certificates()
           names = []
           certificates.each do |current|
             begin
-              names << current.match(/(iPhone Distribution:.*)/)[1]
+              names << current.match(/(#{distribution_name}:.*)/)[1]
             rescue
             end
           end
@@ -105,7 +106,7 @@ module DeployGate
           conflicting_certificates = []
           certificates.each do |current|
             begin
-              name = current.match(/(iPhone Distribution:.*)/)[1]
+              name = current.match(/(#{distribution_name}:.*)/)[1]
               next unless conflicting_names.include?(name)
               conflicting_certificates << current
             rescue
@@ -201,9 +202,10 @@ module DeployGate
           end
         end
 
-        def create_provisioning(identifier, uuid)
-          app = MemberCenters::App.new(identifier)
-          provisioning_prifile = MemberCenters::ProvisioningProfile.new(identifier)
+        def create_provisioning(identifier, uuid, team_id)
+          member_center = Xcode::MemberCenter.new(team_id)
+          app = MemberCenters::App.new(identifier, member_center)
+          provisioning_prifile = MemberCenters::ProvisioningProfile.new(identifier, member_center)
 
           begin
             unless app.created?
@@ -253,12 +255,16 @@ module DeployGate
             exit
           end
 
-          conflicting_certificates = installed_distribution_conflicting_certificates
-          if conflicting_certificates.count > 0
+          iphone_conflicting_certificates = installed_distribution_conflicting_certificates_by('iPhone Distribution')
+          apple_conflicting_certificates = installed_distribution_conflicting_certificates_by('Apple Distribution')
+          if iphone_conflicting_certificates.count > 0 || apple_conflicting_certificates.count > 0
             puts HighLine.color(I18n.t('xcode.export.check_local_certificates.conflict_certificate.error_message'), HighLine::RED)
             puts ''
             puts I18n.t('xcode.export.check_local_certificates.conflict_certificate.note')
-            conflicting_certificates.each do |certificate|
+            iphone_conflicting_certificates.each do |certificate|
+              puts certificate
+            end
+            apple_conflicting_certificates.each do |certificate|
               puts certificate
             end
             puts ""