dependabot-maven 0.308.0 → 0.309.0

data/lib/dependabot/maven/update_checker/property_updater.rb

@@ -1,51 +1,75 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "dependabot/package/release_cooldown_options"
 require "dependabot/maven/file_parser"
 require "dependabot/maven/update_checker"
 require "dependabot/maven/file_updater/declaration_finder"
+require "sorbet-runtime"
 
 module Dependabot
   module Maven
     class UpdateChecker
       class PropertyUpdater
+        extend T::Sig
         require_relative "requirements_updater"
         require_relative "version_finder"
 
-        def initialize(dependency:, dependency_files:, credentials:,
-                       target_version_details:, ignored_versions:)
+        sig do
+          params(
+            dependency: Dependabot::Dependency,
+            dependency_files: T::Array[Dependabot::DependencyFile],
+            credentials: T::Array[Dependabot::Credential],
+            ignored_versions: T::Array[String],
+            target_version_details: T.nilable(T::Hash[T.untyped, T.untyped]),
+            update_cooldown: T.nilable(Dependabot::Package::ReleaseCooldownOptions)
+          ).void
+        end
+        def initialize(
+          dependency:, dependency_files:, credentials:,
+          ignored_versions:, target_version_details:,
+          update_cooldown: nil
+        )
           @dependency       = dependency
           @dependency_files = dependency_files
           @credentials      = credentials
           @ignored_versions = ignored_versions
-          @target_version   = target_version_details&.fetch(:version)
-          @source_url       = target_version_details&.fetch(:source_url)
+          @target_version   = T.let(target_version_details&.fetch(:version), T.nilable(Dependabot::Maven::Version))
+          @source_url       = T.let(target_version_details&.fetch(:source_url), T.nilable(String))
+          @update_cooldown = update_cooldown
         end
 
+        sig { returns(T::Boolean) }
         def update_possible?
           return false unless target_version
-          return @update_possible if defined?(@update_possible)
+          return T.must(@update_possible) if defined?(@update_possible)
 
-          @update_possible =
+          @update_possible ||= T.let(
             dependencies_using_property.all? do |dep|
               next false if includes_property_reference?(updated_version(dep))
 
-              versions = VersionFinder.new(
+              releases = VersionFinder.new(
                 dependency: dep,
                 dependency_files: dependency_files,
                 credentials: credentials,
                 ignored_versions: ignored_versions,
-                security_advisories: []
-              ).versions.map { |v| v.fetch(:version) }
+                security_advisories: [],
+                cooldown_options: update_cooldown
+              ).releases
+
+              versions = releases.map(&:version)
 
               versions.include?(updated_version(dep)) || versions.none?
-            end
+            end,
+            T.nilable(T::Boolean)
+          )
         end
 
+        sig { returns(T::Array[Dependabot::Dependency]) }
         def updated_dependencies
           raise "Update not possible!" unless update_possible?
 
-          @updated_dependencies ||=
+          @updated_dependencies ||= T.let(
             dependencies_using_property.map do |dep|
               Dependency.new(
                 name: dep.name,
@@ -55,20 +79,37 @@ module Dependabot
                 previous_requirements: dep.requirements,
                 package_manager: dep.package_manager
               )
-            end
+            end,
+            T.nilable(T::Array[Dependabot::Dependency])
+          )
         end
 
         private
 
+        sig { returns(Dependabot::Dependency) }
         attr_reader :dependency
+
+        sig { returns(T::Array[Dependabot::DependencyFile]) }
         attr_reader :dependency_files
+
+        sig { returns(T.nilable(Dependabot::Maven::Version)) }
         attr_reader :target_version
+
+        sig { returns(T.nilable(String)) }
         attr_reader :source_url
+
+        sig { returns(T::Array[Dependabot::Credential]) }
         attr_reader :credentials
+
+        sig { returns(T::Array[String]) }
         attr_reader :ignored_versions
 
+        sig { returns(T.nilable(Dependabot::Package::ReleaseCooldownOptions)) }
+        attr_reader :update_cooldown
+
+        sig { returns(T::Array[Dependabot::Dependency]) }
         def dependencies_using_property
-          @dependencies_using_property ||=
+          @dependencies_using_property ||= T.let(
             Maven::FileParser.new(
               dependency_files: dependency_files,
               source: nil
@@ -78,30 +119,41 @@ module Dependabot
 
                 r.dig(:metadata, :property_source) == property_source
               end
-            end
+            end,
+            T.nilable(T::Array[Dependabot::Dependency])
+          )
         end
 
+        sig { returns(String) }
         def property_name
-          @property_name ||= dependency.requirements
-                                       .find { |r| r.dig(:metadata, :property_name) }
-                                       &.dig(:metadata, :property_name)
+          @property_name ||= T.let(
+            dependency.requirements
+                      .find { |r| r.dig(:metadata, :property_name) }
+                      &.dig(:metadata, :property_name),
+            T.nilable(String)
+          )
 
           raise "No requirement with a property name!" unless @property_name
 
           @property_name
         end
 
+        sig { returns(T.nilable(String)) }
         def property_source
-          @property_source ||=
+          @property_source ||= T.let(
             dependency.requirements
                       .find { |r| r.dig(:metadata, :property_name) == property_name }
-                      &.dig(:metadata, :property_source)
+                      &.dig(:metadata, :property_source),
+            T.nilable(String)
+          )
         end
 
+        sig { params(string: String).returns(T::Boolean) }
         def includes_property_reference?(string)
           string.match?(Maven::FileParser::PROPERTY_REGEX)
         end
 
+        sig { params(dep: Dependabot::Dependency).returns(T.nilable(String)) }
         def version_string(dep)
           declaring_requirement =
             dep.requirements
@@ -109,21 +161,24 @@ module Dependabot
 
           Maven::FileUpdater::DeclarationFinder.new(
             dependency: dep,
-            declaring_requirement: declaring_requirement,
+            declaring_requirement: T.must(declaring_requirement),
             dependency_files: dependency_files
-          ).declaration_nodes.first.at_css("version")&.content
+          ).declaration_nodes.first&.at_css("version")&.content
         end
 
+        sig { returns(T.nilable(Dependabot::DependencyFile)) }
         def pom
           dependency_files.find { |f| f.name == "pom.xml" }
         end
 
+        sig { params(dep: Dependabot::Dependency).returns(String) }
         def updated_version(dep)
-          version_string(dep).gsub("${#{property_name}}", target_version.to_s)
+          T.must(version_string(dep)).gsub("${#{property_name}}", T.must(target_version).to_s)
         end
 
+        sig { params(dep: Dependabot::Dependency).returns(T::Array[T::Hash[Symbol, T.untyped]]) }
         def updated_requirements(dep)
-          @updated_requirements ||= {}
+          @updated_requirements ||= T.let({}, T.nilable(T::Hash[String, T::Array[T::Hash[Symbol, T.untyped]]]))
           @updated_requirements[dep.name] ||=
             RequirementsUpdater.new(
               requirements: dep.requirements,

data/lib/dependabot/maven/update_checker/version_finder.rb

@@ -1,20 +1,17 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
-require "nokogiri"
+require "dependabot/package/package_latest_version_finder"
+require "dependabot/package/release_cooldown_options"
 require "dependabot/update_checkers/version_filters"
-require "dependabot/maven/file_parser/repositories_finder"
+require "dependabot/maven/package/package_details_fetcher"
 require "dependabot/maven/update_checker"
-require "dependabot/maven/version"
-require "dependabot/maven/requirement"
-require "dependabot/maven/utils/auth_headers_finder"
-require "dependabot/registry_client"
 require "sorbet-runtime"
 
 module Dependabot
   module Maven
     class UpdateChecker
-      class VersionFinder
+      class VersionFinder < Dependabot::Package::PackageLatestVersionFinder
         extend T::Sig
 
         TYPE_SUFFICES = %w(jre android java native_mt agp).freeze
@@ -26,18 +23,13 @@ module Dependabot
             credentials: T::Array[Dependabot::Credential],
             ignored_versions: T::Array[String],
             security_advisories: T::Array[Dependabot::SecurityAdvisory],
+            cooldown_options: T.nilable(Dependabot::Package::ReleaseCooldownOptions),
             raise_on_ignored: T::Boolean
           ).void
         end
         def initialize(dependency:, dependency_files:, credentials:,
                        ignored_versions:, security_advisories:,
-                       raise_on_ignored: false)
-          @dependency          = dependency
-          @dependency_files    = dependency_files
-          @credentials         = credentials
-          @ignored_versions    = ignored_versions
-          @raise_on_ignored    = raise_on_ignored
-          @security_advisories = security_advisories
+                       cooldown_options: nil, raise_on_ignored: false)
           @forbidden_urls      = T.let([], T::Array[String])
           @dependency_metadata = T.let({}, T::Hash[T.untyped, Nokogiri::XML::Document])
           @auth_headers_finder = T.let(nil, T.nilable(Utils::AuthHeadersFinder))
@@ -45,94 +37,133 @@ module Dependabot
           @repository_finder = T.let(nil, T.nilable(Maven::FileParser::RepositoriesFinder))
           @repositories = T.let(nil, T.nilable(T::Array[T::Hash[String, T.untyped]]))
           @released_check = T.let({}, T::Hash[Version, T::Boolean])
+          @package_details_fetcher = T.let(nil, T.nilable(Package::PackageDetailsFetcher))
+          @package_details = T.let(nil, T.nilable(Dependabot::Package::PackageDetails))
+          super
         end
 
-        sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
-        def latest_version_details
-          possible_versions = versions
+        sig { override.returns(T.nilable(Dependabot::Package::PackageDetails)) }
+        def package_details
+          @package_details ||= package_details_fetcher.fetch
+        end
 
-          possible_versions = filter_prereleases(possible_versions)
-          possible_versions = filter_date_based_versions(possible_versions)
-          possible_versions = filter_version_types(possible_versions)
-          possible_versions = filter_ignored_versions(possible_versions)
+        sig { returns(T::Array[Dependabot::Package::PackageRelease]) }
+        def releases
+          (package_details&.releases || []).reverse
+        end
 
-          possible_versions.reverse.find { |v| released?(v.fetch(:version)) }
+        sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+        def latest_version_details
+          release = fetch_latest_release
+          release ? { version: release.version, source_url: release.url } : nil
         end
 
         sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
         def lowest_security_fix_version_details
-          possible_versions = versions
+          release = fetch_lowest_security_fix_release
+          release ? { version: release.version, source_url: release.url } : nil
+        end
 
-          possible_versions = filter_prereleases(possible_versions)
-          possible_versions = filter_date_based_versions(possible_versions)
-          possible_versions = filter_version_types(possible_versions)
-          possible_versions = Dependabot::UpdateCheckers::VersionFilters.filter_vulnerable_versions(possible_versions,
-                                                                                                    security_advisories)
-          possible_versions = filter_ignored_versions(possible_versions)
-          possible_versions = filter_lower_versions(possible_versions)
+        protected
 
-          possible_versions.find { |v| released?(v.fetch(:version)) }
+        sig { returns(T::Boolean) }
+        def cooldown_enabled?
+          Dependabot::Experiments.enabled?(:enable_cooldown_for_maven)
         end
 
-        sig { returns(T::Array[T.untyped]) }
-        def versions
-          version_details =
-            repositories.map do |repository_details|
-              url = repository_details.fetch("url")
-              xml = dependency_metadata(repository_details)
-              next [] if xml.nil?
+        sig do
+          params(language_version: T.nilable(T.any(String, Dependabot::Version)))
+            .returns(T.nilable(Dependabot::Version))
+        end
+        def fetch_latest_version(language_version: nil)
+          fetch_latest_release(language_version: language_version)&.version
+        end
 
-              break xml.css("versions > version")
-                       .select { |node| version_class.correct?(node.content) }
-                       .map { |node| version_class.new(node.content) }
-                       .map { |version| { version: version, source_url: url } }
-            end.flatten
+        sig do
+          params(language_version: T.nilable(T.any(String, Dependabot::Version)))
+            .returns(T.nilable(Dependabot::Version))
+        end
+        def fetch_latest_version_with_no_unlock(language_version:)
+          fetch_latest_release(language_version: language_version)&.version
+        end
 
-          raise PrivateSourceAuthenticationFailure, forbidden_urls.first if version_details.none? && forbidden_urls.any?
+        sig do
+          params(language_version: T.nilable(T.any(String, Dependabot::Version)))
+            .returns(T.nilable(Dependabot::Version))
+        end
+        def fetch_lowest_security_fix_version(language_version: nil)
+          fetch_lowest_security_fix_release(language_version: language_version)&.version
+        end
 
-          version_details.sort_by { |details| details.fetch(:version) }
+        sig do
+          params(language_version: T.nilable(T.any(String, Dependabot::Version)))
+            .returns(T.nilable(Dependabot::Package::PackageRelease))
+        end
+        def fetch_latest_release(language_version: nil) # rubocop:disable Lint/UnusedMethodArgument
+          possible_releases = filter_prerelease_versions(releases)
+          possible_releases = filter_date_based_versions(possible_releases)
+          possible_releases = filter_version_types(possible_releases)
+          possible_releases = filter_ignored_versions(possible_releases)
+          possible_releases = filter_by_cooldown(possible_releases)
+          possible_releases_reverse = possible_releases.reverse
+
+          possible_releases_reverse.find do |r|
+            package_details_fetcher.released?(r.version)
+          end
         end
 
-        private
+        sig do
+          params(language_version: T.nilable(T.any(String, Dependabot::Version)))
+            .returns(T.nilable(Dependabot::Package::PackageRelease))
+        end
+        def fetch_lowest_security_fix_release(language_version: nil) # rubocop:disable Lint/UnusedMethodArgument
+          possible_releases = filter_prerelease_versions(releases)
+          possible_releases = filter_date_based_versions(possible_releases)
+          possible_releases = filter_version_types(possible_releases)
+          possible_releases = Dependabot::UpdateCheckers::VersionFilters
+                              .filter_vulnerable_versions(
+                                possible_releases,
+                                security_advisories
+                              )
+          possible_releases = filter_ignored_versions(possible_releases)
+          possible_releases = filter_lower_versions(possible_releases)
 
-        sig { returns(Dependabot::Dependency) }
-        attr_reader :dependency
-        sig { returns(T::Array[Dependabot::DependencyFile]) }
-        attr_reader :dependency_files
-        sig { returns(T::Array[Dependabot::Credential]) }
-        attr_reader :credentials
-        sig { returns(T::Array[String]) }
-        attr_reader :ignored_versions
-        sig { returns(T::Array[String]) }
-        attr_reader :forbidden_urls
-        sig { returns(T::Array[Dependabot::SecurityAdvisory]) }
-        attr_reader :security_advisories
+          possible_releases.find { |r| package_details_fetcher.released?(r.version) }
+        end
 
-        sig { params(possible_versions: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
-        def filter_prereleases(possible_versions)
-          return possible_versions if wants_prerelease?
+        private
 
-          filtered = possible_versions.reject { |v| v.fetch(:version).prerelease? }
-          if possible_versions.count > filtered.count
-            Dependabot.logger.info("Filtered out #{possible_versions.count - filtered.count} pre-release versions")
-          end
-          filtered
+        sig { returns(Package::PackageDetailsFetcher) }
+        def package_details_fetcher
+          @package_details_fetcher ||= Package::PackageDetailsFetcher.new(
+            dependency: dependency,
+            dependency_files: dependency_files,
+            credentials: credentials
+          )
         end
 
-        sig { params(possible_versions: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+        sig do
+          params(possible_versions: T::Array[Dependabot::Package::PackageRelease])
+            .returns(T::Array[Dependabot::Package::PackageRelease])
+        end
         def filter_date_based_versions(possible_versions)
           return possible_versions if wants_date_based_version?
 
-          filtered = possible_versions.reject { |v| v.fetch(:version) > version_class.new(1900) }
+          filtered = possible_versions.reject { |release| release.version > version_class.new(1900) }
           if possible_versions.count > filtered.count
             Dependabot.logger.info("Filtered out #{possible_versions.count - filtered.count} date-based versions")
           end
           filtered
         end
 
-        sig { params(possible_versions: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+        sig do
+          params(possible_versions: T::Array[Dependabot::Package::PackageRelease])
+            .returns(T::Array[Dependabot::Package::PackageRelease])
+        end
         def filter_version_types(possible_versions)
-          filtered = possible_versions.select { |v| matches_dependency_version_type?(v.fetch(:version)) }
+          filtered = possible_versions.select do |release|
+            matches_dependency_version_type?(release.version)
+          end
           if possible_versions.count > filtered.count
             diff = possible_versions.count - filtered.count
             classifier = dependency.version&.split(/[.\-]/)&.last
@@ -141,39 +172,6 @@ module Dependabot
           filtered
         end
 
-        sig { params(possible_versions: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
-        def filter_ignored_versions(possible_versions)
-          filtered = possible_versions
-
-          ignored_versions.each do |req|
-            ignore_requirements = Maven::Requirement.requirements_array(req)
-            filtered =
-              filtered
-              .reject { |v| ignore_requirements.any? { |r| r.satisfied_by?(v.fetch(:version)) } }
-          end
-
-          if @raise_on_ignored && filter_lower_versions(filtered).empty? &&
-             filter_lower_versions(possible_versions).any?
-            raise AllVersionsIgnored
-          end
-
-          if possible_versions.count > filtered.count
-            diff = possible_versions.count - filtered.count
-            Dependabot.logger.info("Filtered out #{diff} ignored versions")
-          end
-
-          filtered
-        end
-
-        sig { params(possible_versions: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
-        def filter_lower_versions(possible_versions)
-          return possible_versions unless dependency.numeric_version
-
-          possible_versions.select do |v|
-            v.fetch(:version) > dependency.numeric_version
-          end
-        end
-
         sig { returns(T::Boolean) }
         def wants_prerelease?
           return false unless dependency.numeric_version
@@ -188,124 +186,7 @@ module Dependabot
           T.must(dependency.numeric_version) >= version_class.new(100)
         end
 
-        sig { params(version: Version).returns(T::Boolean) }
-        def released?(version)
-          @released_check[version] ||=
-            repositories.any? do |repository_details|
-              url = repository_details.fetch("url")
-              response = Dependabot::RegistryClient.head(
-                url: dependency_files_url(url, version),
-                headers: repository_details.fetch("auth_headers")
-              )
-
-              response.status < 400
-            rescue Excon::Error::Socket, Excon::Error::Timeout,
-                   Excon::Error::TooManyRedirects
-              false
-            rescue URI::InvalidURIError => e
-              raise DependencyFileNotResolvable, e.message
-            end
-        end
-
-        sig { params(repository_details: T::Hash[String, T.untyped]).returns(T.nilable(Nokogiri::XML::Document)) }
-        def dependency_metadata(repository_details)
-          repository_key = repository_details.hash
-          return @dependency_metadata[repository_key] if @dependency_metadata.key?(repository_key)
-
-          xml_document = fetch_dependency_metadata(repository_details)
-
-          @dependency_metadata[repository_key] ||= xml_document if xml_document
-          @dependency_metadata[repository_key]
-        end
-
-        sig { params(repository_details: T::Hash[String, T.untyped]).returns(T.nilable(Nokogiri::XML::Document)) }
-        def fetch_dependency_metadata(repository_details)
-          response = Dependabot::RegistryClient.get(
-            url: dependency_metadata_url(repository_details.fetch("url")),
-            headers: repository_details.fetch("auth_headers")
-          )
-          check_response(response, repository_details.fetch("url"))
-          return unless response.status < 400
-
-          Nokogiri::XML(response.body)
-        rescue URI::InvalidURIError
-          nil
-        rescue Excon::Error::Socket, Excon::Error::Timeout,
-               Excon::Error::TooManyRedirects => e
-
-          if central_repo_urls.include?(repository_details["url"])
-            response_status = response&.status || 0
-            response_body = if response
-                              "RegistryError: #{response.status} response status with body #{response.body}"
-                            else
-                              "RegistryError: #{e.message}"
-                            end
-
-            raise RegistryError.new(response_status, response_body)
-          end
-
-          nil
-        end
-
-        sig { params(response: Excon::Response, repository_url: String).void }
-        def check_response(response, repository_url)
-          return unless [401, 403].include?(response.status)
-          return if @forbidden_urls.include?(repository_url)
-          return if central_repo_urls.include?(repository_url)
-
-          @forbidden_urls << repository_url
-        end
-
-        sig { returns(T::Array[T::Hash[String, T.untyped]]) }
-        def repositories
-          return @repositories if @repositories
-
-          @repositories = credentials_repository_details
-          pom_repository_details.each do |repo|
-            @repositories << repo unless @repositories.any? { |r| r["url"] == repo["url"] }
-          end
-          @repositories
-        end
-
-        sig { returns(Maven::FileParser::RepositoriesFinder) }
-        def repository_finder
-          return @repository_finder if @repository_finder
-
-          @repository_finder =
-            Maven::FileParser::RepositoriesFinder.new(
-              pom_fetcher: Maven::FileParser::PomFetcher.new(dependency_files: dependency_files),
-              dependency_files: dependency_files,
-              credentials: credentials
-            )
-          @repository_finder
-        end
-
-        sig { returns(T::Array[T::Hash[String, T.untyped]]) }
-        def pom_repository_details
-          return @pom_repository_details if @pom_repository_details
-
-          @pom_repository_details =
-            repository_finder
-            .repository_urls(pom: pom)
-            .map do |url|
-              { "url" => url, "auth_headers" => {} }
-            end
-          @pom_repository_details
-        end
-
-        sig { returns(T::Array[T.untyped]) }
-        def credentials_repository_details
-          credentials
-            .select { |cred| cred["type"] == "maven_repository" && cred["url"] }
-            .map do |cred|
-              {
-                "url" => cred.fetch("url").gsub(%r{/+$}, ""),
-                "auth_headers" => auth_headers(cred.fetch("url").gsub(%r{/+$}, ""))
-              }
-            end
-        end
-
-        sig { params(comparison_version: Version).returns(T::Boolean) }
+        sig { params(comparison_version: Dependabot::Version).returns(T::Boolean) }
         def matches_dependency_version_type?(comparison_version)
           return true unless dependency.version
 
@@ -326,60 +207,10 @@ module Dependabot
           current_type == version_type
         end
 
-        sig { returns(T.nilable(Dependabot::DependencyFile)) }
-        def pom
-          filename = dependency.requirements.first&.fetch(:file)
-          dependency_files.find { |f| f.name == filename }
-        end
-
-        sig { params(repository_url: String).returns(String) }
-        def dependency_metadata_url(repository_url)
-          group_id, artifact_id = dependency.name.split(":")
-
-          "#{repository_url}/" \
-            "#{group_id&.tr('.', '/')}/" \
-            "#{artifact_id}/" \
-            "maven-metadata.xml"
-        end
-
-        sig { params(repository_url: String, version: Version).returns(String) }
-        def dependency_files_url(repository_url, version)
-          group_id, artifact_id = dependency.name.split(":")
-          type = dependency.requirements.first&.dig(:metadata, :packaging_type)
-          classifier = dependency.requirements.first&.dig(:metadata, :classifier)
-
-          actual_classifier = classifier.nil? ? "" : "-#{classifier}"
-          "#{repository_url}/" \
-            "#{group_id&.tr('.', '/')}/" \
-            "#{artifact_id}/" \
-            "#{version}/" \
-            "#{artifact_id}-#{version}#{actual_classifier}.#{type}"
-        end
-
         sig { returns(T.class_of(Dependabot::Version)) }
         def version_class
           dependency.version_class
         end
-
-        sig { returns(T::Array[String]) }
-        def central_repo_urls
-          central_url_without_protocol = repository_finder.central_repo_url.gsub(%r{^.*://}, "")
-
-          %w(http:// https://).map { |p| p + central_url_without_protocol }
-        end
-
-        sig { returns(Utils::AuthHeadersFinder) }
-        def auth_headers_finder
-          return @auth_headers_finder if @auth_headers_finder
-
-          @auth_headers_finder = Utils::AuthHeadersFinder.new(credentials)
-          @auth_headers_finder
-        end
-
-        sig { params(maven_repo_url: String).returns(T::Hash[String, String]) }
-        def auth_headers(maven_repo_url)
-          auth_headers_finder.auth_headers(maven_repo_url)
-        end
       end
     end
   end