Refactor Go module proxy to add finders

ee/app/finders/packages/go/module_finder.rb

+# frozen_string_literal: true
+
+module Packages
+  module Go
+    class ModuleFinder
+      include ::API::Helpers::Packages::Go::ModuleHelpers
+
+      attr_reader :project, :module_name
+
+      def initialize(project, module_name)
+        module_name = Pathname.new(module_name).cleanpath.to_s
+
+        @project = project
+        @module_name = module_name
+      end
+
+      def execute
+        return if @module_name.blank?
+
+        if @module_name == package_base
+          Packages::GoModule.new(@project, @module_name, '')
+        elsif @module_name.start_with?(package_base + '/')
+          Packages::GoModule.new(@project, @module_name, @module_name[(package_base.length + 1)..])
+        else
+          nil
+        end
+      end
+
+      private
+
+      def package_base
+        @package_base ||= Gitlab::Routing.url_helpers.project_url(@project).split('://', 2)[1]
+      end
+    end
+  end
+end

ee/app/finders/packages/go/version_finder.rb

+# frozen_string_literal: true
+
+module Packages
+  module Go
+    class VersionFinder
+      include ::API::Helpers::Packages::Go::ModuleHelpers
+
+      attr_reader :mod
+
+      def initialize(mod)
+        @mod = mod
+      end
+
+      def execute
+        @mod.project.repository.tags
+          .filter { |tag| semver? tag }
+          .map    { |tag| find_ref tag }
+          .filter { |ver| ver.valid? }
+      end
+
+      def find(target)
+        case target
+        when String
+          unless pseudo_version? target
+            return mod.versions.filter { |v| v.name == target }.first
+          end
+
+          begin
+            find_pseudo_version target
+          rescue ArgumentError
+            nil
+          end
+
+        when Gitlab::Git::Ref
+          find_ref target
+
+        when ::Commit, Gitlab::Git::Commit
+          find_commit target
+
+        else
+          raise ArgumentError.new 'not a valid target'
+        end
+      end
+
+      private
+
+      def find_ref(ref)
+        commit = ref.dereferenced_target
+        Packages::GoModuleVersion.new(@mod, :ref, commit, ref: ref, semver: parse_semver(ref.name))
+      end
+
+      def find_commit(commit)
+        Packages::GoModuleVersion.new(@mod, :commit, commit)
+      end
+
+      def find_pseudo_version(str)
+        semver = parse_semver(str)
+        raise ArgumentError.new 'target is not a pseudo-version' unless semver && PSEUDO_VERSION_REGEX.match?(str)
+
+        # valid pseudo-versions are
+        #   vX.0.0-yyyymmddhhmmss-sha1337beef0, when no earlier tagged commit exists for X
+        #   vX.Y.Z-pre.0.yyyymmddhhmmss-sha1337beef0, when most recent prior tag is vX.Y.Z-pre
+        #   vX.Y.(Z+1)-0.yyyymmddhhmmss-sha1337beef0, when most recent prior tag is vX.Y.Z
+
+        # go discards the timestamp when resolving pseudo-versions, so we will do the same
+
+        timestamp, sha = semver.prerelease.split('-').last 2
+        timestamp = timestamp.split('.').last
+        commit = @mod.project.repository.commit_by(oid: sha)
+
+        # these errors are copied from proxy.golang.org's responses
+        raise ArgumentError.new 'invalid pseudo-version: unknown commit' unless commit
+        raise ArgumentError.new 'invalid pseudo-version: revision is shorter than canonical' unless sha.length == 12
+        raise ArgumentError.new 'invalid pseudo-version: does not match version-control timestamp' unless commit.committed_date.strftime('%Y%m%d%H%M%S') == timestamp
+
+        Packages::GoModuleVersion.new(@mod, :pseudo, commit, name: str, semver: semver)
+      end
+    end
+  end
+end

ee/app/models/packages/go_module.rb

@@ -3,42 +3,32 @@
 class Packages::GoModule
   attr_reader :project, :name, :path
 
-  def initialize(project, name)
+  def initialize(project, name, path)
     @project = project
     @name = name
-
-    @path =
-      if @name == package_base
-        ''
-      elsif @name.start_with?(package_base + '/')
-        @name[(package_base.length + 1)..]
-      else
-        nil
-      end
+    @path = path
   end
 
   def versions
-    @versions ||= @project.repository.tags
-      .filter { |tag| ::Packages::GoModuleVersion.semver? tag }
-      .map    { |tag| ::Packages::GoModuleVersion.new self, tag }
-      .filter { |ver| ver.valid? }
+    @versions ||= Packages::Go::VersionFinder.new(self).execute
   end
 
   def find_version(name)
-    if ::Packages::GoModuleVersion.pseudo_version? name
-      begin
-        ::Packages::GoModuleVersion.new self, name
-      rescue ArgumentError
-        nil
+    Packages::Go::VersionFinder.new(self).find(name)
   end
+
+  def path_valid?(major)
+    m = /\/v(\d+)$/i.match(@name)
+
+    case major
+    when 0, 1
+      m.nil?
     else
-      versions.filter { |ver| ver.name == name }.first
+      !m.nil? && m[1].to_i == major
     end
   end
 
-  private
-
-  def package_base
-    @package_base ||= Gitlab::Routing.url_helpers.project_url(@project).split('://', 2)[1]
+  def gomod_valid?(gomod)
+    gomod&.split("\n", 2)&.first == "module #{@name}"
   end
 end

ee/app/models/packages/go_module_version.rb

 # frozen_string_literal: true
 
 class Packages::GoModuleVersion
-  SEMVER_REGEX = /v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([-.a-z0-9]+))?(?:\+([-.a-z0-9]+))?/i.freeze
-  SEMVER_TAG_REGEX = /^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([-.a-z0-9]+))?(?:\+([-.a-z0-9]+))?$/i.freeze
-  PSEUDO_VERSION_REGEX = /^v\d+\.(0\.0-|\d+\.\d+-([^+]*\.)?0\.)\d{14}-[A-Za-z0-9]+(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/i.freeze
-  VERSION_SUFFIX_REGEX = /\/v([1-9]\d*)$/i.freeze
+  include ::API::Helpers::Packages::Go::ModuleHelpers
 
   attr_reader :mod, :type, :ref, :commit
 
@@ -14,57 +11,13 @@ class Packages::GoModuleVersion
   delegate :prerelease, to: :@semver, allow_nil: true
   delegate :build, to: :@semver, allow_nil: true
 
-  def self.semver?(tag)
-    return false if tag.dereferenced_target.nil?
-
-    SEMVER_TAG_REGEX.match?(tag.name)
-  end
-
-  def self.pseudo_version?(str)
-    SEMVER_TAG_REGEX.match?(str) && PSEUDO_VERSION_REGEX.match?(str)
-  end
-
-  def initialize(mod, target)
+  def initialize(mod, type, commit, name: nil, semver: nil, ref: nil)
     @mod = mod
-
-    case target
-    when String
-      m = SEMVER_TAG_REGEX.match(target)
-      raise ArgumentError.new 'target is not a pseudo-version' unless m && PSEUDO_VERSION_REGEX.match?(target)
-
-      # valid pseudo-versions are
-      #   vX.0.0-yyyymmddhhmmss-sha1337beef0, when no earlier tagged commit exists for X
-      #   vX.Y.Z-pre.0.yyyymmddhhmmss-sha1337beef0, when most recent prior tag is vX.Y.Z-pre
-      #   vX.Y.(Z+1)-0.yyyymmddhhmmss-sha1337beef0, when most recent prior tag is vX.Y.Z
-
-      # go discards the timestamp when resolving pseudo-versions, so we will do the same
-
-      @type = :pseudo
-      @name = target
-      @semver = semver_match_to_hash m
-
-      timestamp, sha = prerelease.split('-').last 2
-      timestamp = timestamp.split('.').last
-      @commit = mod.project.repository.commit_by(oid: sha)
-
-      # these errors are copied from proxy.golang.org's responses
-      raise ArgumentError.new 'invalid pseudo-version: unknown commit' unless @commit
-      raise ArgumentError.new 'invalid pseudo-version: revision is shorter than canonical' unless sha.length == 12
-      raise ArgumentError.new 'invalid pseudo-version: does not match version-control timestamp' unless @commit.committed_date.strftime('%Y%m%d%H%M%S') == timestamp
-
-    when Gitlab::Git::Ref
-      @type = :ref
-      @ref = target
-      @commit = target.dereferenced_target
-      @semver = semver_match_to_hash SEMVER_TAG_REGEX.match(target.name)
-
-    when ::Commit, Gitlab::Git::Commit
-      @type = :commit
-      @commit = target
-
-    else
-      raise ArgumentError.new 'not a valid target'
-    end
+    @type = type
+    @commit = commit
+    @name = name if name
+    @semver = semver if semver
+    @ref = ref if ref
   end
 
   def name
@@ -72,36 +25,11 @@ class Packages::GoModuleVersion
   end
 
   def gomod
-    @gomod ||= @mod.project.repository.blob_at(@commit.sha, @mod.path + '/go.mod')&.data
-  end
-
-  def valid?
-    valid_path? && valid_module?
-  end
-
-  def valid_path?
-    m = VERSION_SUFFIX_REGEX.match(@mod.name)
-
-    case major
-    when 0, 1
-      m.nil?
-    else
-      !m.nil? && m[1].to_i == major
-    end
-  end
-
-  def valid_module?
-    return false unless gomod
-
-    gomod.split("\n", 2).first == "module #{@mod.name}"
-  end
-
-  def pseudo?
-    @type == :pseudo
+    @gomod ||= blob_at(@mod.path + '/go.mod')
   end
 
   def files
-    return @files unless @files.nil?
+    return @files if defined?(@files)
 
     sha = @commit.sha
     tree = @mod.project.repository.tree(sha, @mod.path, recursive: true).entries.filter { |e| e.file? }
@@ -110,19 +38,10 @@ class Packages::GoModuleVersion
   end
 
   def blob_at(path)
-    @mod.project.repository.blob_at(@commit.sha, path).data
+    @mod.project.repository.blob_at(@commit.sha, path)&.data
   end
 
-  private
-
-  def semver_match_to_hash(match)
-    return unless match
-
-    OpenStruct.new(
-      major: match[1].to_i,
-      minor: match[2].to_i,
-      patch: match[3].to_i,
-      prerelease: match[4],
-      build: match[5])
+  def valid?
+    @mod.path_valid?(major) && @mod.gomod_valid?(gomod)
   end
 end

ee/lib/api/go_proxy.rb

@@ -2,8 +2,11 @@
 module API
   class GoProxy < Grape::API
     helpers ::API::Helpers::PackagesHelpers
+    helpers ::API::Helpers::Packages::Go::ModuleHelpers
 
+    # basic semver, except case encoded (A => !a)
     MODULE_VERSION_REGEX = /v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([-.!a-z0-9]+))?(?:\+([-.!a-z0-9]+))?/.freeze
+
     MODULE_VERSION_REQUIREMENTS = { module_version: MODULE_VERSION_REGEX }.freeze
 
     before { require_packages_enabled! }
@@ -15,25 +18,24 @@ module API
 
       def find_module
         module_name = case_decode params[:module_name]
-
         bad_request!('Module Name') if module_name.blank?
 
-        mod = ::Packages::GoModule.new user_project, module_name
-        not_found! if mod.path.nil?
+        mod = ::Packages::Go::ModuleFinder.new(user_project, module_name).execute
+
+        not_found! unless mod
 
         mod
       end
 
       def find_version
-        mod = find_module
+        module_version = case_decode params[:module_version]
+        ver = ::Packages::Go::VersionFinder.new(find_module).find(module_version)
 
-        ver = mod.find_version case_decode params[:module_version]
         not_found! unless ver&.valid?
 
         ver
       end
 
-      # override :find_project!
       def find_project!(id)
         project = find_project(id)
 

ee/lib/api/helpers/packages/go/module_helpers.rb

+# frozen_string_literal: true
+
+module API
+  module Helpers
+    module Packages
+      module Go
+        module ModuleHelpers
+          # basic semver regex
+          SEMVER_REGEX = /v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([-.a-z0-9]+))?(?:\+([-.a-z0-9]+))?/i.freeze
+
+          # basic semver, but bounded (^expr$)
+          SEMVER_TAG_REGEX = /^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([-.a-z0-9]+))?(?:\+([-.a-z0-9]+))?$/i.freeze
+
+          # semver, but the prerelease component follows a specific format
+          PSEUDO_VERSION_REGEX = /^v\d+\.(0\.0-|\d+\.\d+-([^+]*\.)?0\.)\d{14}-[A-Za-z0-9]+(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/i.freeze
+
+          def case_encode(str)
+            str.gsub(/A-Z/) { |s| "!#{s.downcase}"}
+          end
+
+          def case_decode(str)
+            str.gsub(/![[:alpha:]]/) { |s| s[1..].upcase }
+          end
+
+          def semver?(tag)
+            return false if tag.dereferenced_target.nil?
+
+            SEMVER_TAG_REGEX.match?(tag.name)
+          end
+
+          def pseudo_version?(str)
+            SEMVER_TAG_REGEX.match?(str) && PSEUDO_VERSION_REGEX.match?(str)
+          end
+
+          def parse_semver(str)
+            m = SEMVER_TAG_REGEX.match(str)
+            return unless m
+
+            OpenStruct.new(
+              major: m[1].to_i,
+              minor: m[2].to_i,
+              patch: m[3].to_i,
+              prerelease: m[4],
+              build: m[5])
+          end
+        end
+      end
+    end
+  end
+end