Packaging should handle missing platform versions

When packaging the Java buildpack it should just report that the requested
version for a specific platform can not be found and carry on. This commit makes
that change.

[#77005312]

Author: Christopher Frost

lib/java_buildpack/repository/repository_index.rb

@@ -50,9 +50,10 @@ def initialize(repository_root)
       # @return [TokenizedVersion] the version of the file found
       # @return [String] the URI of the file found
       def find_item(version)
-        version = VersionResolver.resolve(version, @index.keys)
-        uri     = @index[version.to_s]
-        [version, uri]
+        found_version = VersionResolver.resolve(version, @index.keys)
+        fail "No version resolvable for '#{version}' in #{@index.keys.join(', ')}" if found_version.nil?
+        uri     = @index[found_version.to_s]
+        [found_version, uri]
       end
 
       private

lib/java_buildpack/repository/version_resolver.rb

@@ -35,8 +35,7 @@ class << self
         # @param [TokenizedVersion] candidate_version the version, possibly containing a wildcard, to resolve.  If +nil+,
         #                                        substituted with +.
         # @param [Array<String>] versions the collection of versions to resolve against
-        # @return [TokenizedVersion] the resolved version
-        # @raise if no version can be resolved
+        # @return [TokenizedVersion] the resolved version or nil if no matching version is found
         def resolve(candidate_version, versions)
           tokenized_candidate_version = safe_candidate_version candidate_version
           tokenized_versions          = versions.map { |version| JavaBuildpack::Util::TokenizedVersion.new(version, false) }
@@ -45,7 +44,6 @@ def resolve(candidate_version, versions)
           .select { |tokenized_version| matches? tokenized_candidate_version, tokenized_version }
           .max { |a, b| a <=> b }
 
-          fail "No version resolvable for '#{candidate_version}' in #{versions.join(', ')}" if version.nil?
           version
         end
 

rakelib/dependency_cache_task.rb

@@ -53,36 +53,43 @@ def initialize
 
     private_constant :ARCHITECTURE_PATTERN, :DEFAULT_REPOSITORY_ROOT_PATTERN, :PLATFORM_PATTERN
 
-    def augment(raw, pattern, candidates, &block)
-      if raw.respond_to? :map
+    def augment(raw, key, pattern, candidates, &block)
+      if raw.respond_to? :at
         raw.map(&block)
       else
-        raw =~ pattern ? candidates.map { |p| raw.gsub pattern, p } : raw
+        if raw[:uri] =~ pattern
+          candidates.map do |candidate|
+            dup       = raw.clone
+            dup[key]  = candidate
+            dup[:uri] = raw[:uri].gsub pattern, candidate
+
+            dup
+          end
+        else
+          raw
+        end
       end
     end
 
     def augment_architecture(raw)
-      augment(raw, ARCHITECTURE_PATTERN, ARCHITECTURES) { |r| augment_architecture r }
+      augment(raw, :architecture, ARCHITECTURE_PATTERN, ARCHITECTURES) { |r| augment_architecture r }
     end
 
     def augment_path(raw)
-      if raw.respond_to? :map
+      if raw.respond_to? :at
         raw.map { |r| augment_path r }
       else
-        "#{raw.chomp('/')}/index.yml"
+        raw[:uri] = "#{raw[:uri].chomp('/')}/index.yml"
+        raw
       end
     end
 
     def augment_platform(raw)
-      augment(raw, PLATFORM_PATTERN, PLATFORMS) { |r| augment_platform r }
+      augment(raw, :platform, PLATFORM_PATTERN, PLATFORMS) { |r| augment_platform r }
     end
 
     def augment_repository_root(raw)
-      if raw.respond_to? :map
-        raw.map { |r| augment_repository_root r }
-      else
-        raw.gsub DEFAULT_REPOSITORY_ROOT_PATTERN, @default_repository_root
-      end
+      augment(raw, :repository_root, DEFAULT_REPOSITORY_ROOT_PATTERN, [@default_repository_root]) { |r| augment_repository_root r }
     end
 
     def cache
@@ -122,8 +129,9 @@ def default_repository_root
       configuration('repository')['default_repository_root'].chomp('/')
     end
 
-    def index_uris(configuration)
+    def index_configuration(configuration)
       [configuration['repository_root']]
+      .map { |r| { uri: r } }
       .map { |r| augment_repository_root r }
       .map { |r| augment_platform r }
       .map { |r| augment_architecture r }
@@ -138,12 +146,14 @@ def uris(configurations)
       uris = []
 
       configurations.each do |configuration|
-        index_uris(configuration).each do |index_uri|
-          multitask PACKAGE_NAME => [cache_task(index_uri)]
-
-          @cache.get(index_uri) do |f|
-            index = YAML.load f
-            uris << index[version(configuration, index).to_s]
+        index_configuration(configuration).each do |index_configuration|
+          multitask PACKAGE_NAME => [cache_task(index_configuration[:uri])]
+
+          @cache.get(index_configuration[:uri]) do |f|
+            index         = YAML.load f
+            found_version = version(configuration, index)
+            rake_output_message "Unable to resolve version '#{configuration['version']}' for platform '#{index_configuration[:platform]}'" if found_version.nil?
+            uris << index[found_version.to_s] unless found_version.nil?
           end
         end
       end

spec/java_buildpack/repository/version_resolver_spec.rb

@@ -53,7 +53,7 @@
   end
 
   it 'should raise an exception if no version can be resolved' do
-    expect { described_class.resolve(tokenized_version('2.1.0'), versions) }.to raise_error
+    expect(described_class.resolve(tokenized_version('2.1.0'), versions)).to be_nil
   end
 
   it 'should raise an exception when a wildcard is specified in the [] collection' do