Skip to content

Commit

Permalink
refined the ecosystem code
Browse files Browse the repository at this point in the history
  • Loading branch information
@kbukum1
kbukum1 committed Oct 23, 2024
1 parent 3979004 commit 5b5a020
Showing 1 changed file with 45 additions and 47 deletions.
92 changes: 45 additions & 47 deletions common/lib/dependabot/ecosystem.rb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,14 +13,14 @@ class VersionManager

abstract!
# Initialize version information with optional requirement
# @param name [String] the name of the package manager or language (e.g., "bundler", "ruby").
# @param name [String] the name for the package manager or language (e.g., "bundler", "ruby").
# @param raw_version [String] the raw current version of the package manager or language.
# @param version [Dependabot::Version] the parsed current version.
# @param deprecated_versions [Array<Dependabot::Version>] an array of deprecated versions.
# @param supported_versions [Array<Dependabot::Version>] an array of supported versions.
# @param requirement [T.nilable(Requirement)] the version requirements, optional.
# @example
# VersionInformation.new("bundler", "2.1.4", Dependabot::Version.new("2.1.4"), nil)
# VersionManager.new("bundler", "2.1.4", Dependabot::Version.new("2.1.4"), nil)
sig do
params(
name: String,
Expand Down Expand Up @@ -50,26 +50,26 @@ def initialize( # rubocop:disable Metrics/ParameterLists

# The name of the package manager or language (e.g., "bundler", "ruby").
# @example
# version_information.name #=> "bundler"
# name #=> "bundler"
sig { returns(String) }
attr_reader :name

# The current version of the package manager or language.
# @example
# version_information.version #=> Dependabot::Version.new("2.1.4")
# version #=> Dependabot::Version.new("2.1.4")
sig { returns(Dependabot::Version) }
attr_reader :version

# The raw current version of the package manager or language as a string.
# @example
# version_information.raw_version #=> "2.1.4"
# raw_version #=> "2.1.4"
sig { returns(String) }
attr_reader :raw_version

# The version requirements (optional).
# @example
# version_information.requirement #=> Requirement.new(">= 2.1")
sig { returns(T.nilable(Ecosystem::Requirement)) }
# requirement #=> Requirement.new(">= 2.1")
sig { returns(T.nilable(Requirement)) }
attr_reader :requirement

# Returns an array of deprecated versions of the package manager.
Expand All @@ -85,18 +85,17 @@ def initialize( # rubocop:disable Metrics/ParameterLists
# Checks if the current version is deprecated.
# Returns true if the version is in the deprecated_versions array; false otherwise.
# @example
# package_manager.deprecated? #=> true
# deprecated? #=> true
sig { returns(T::Boolean) }
def deprecated?
# If the version is unsupported, the unsupported error is getting raised separately.
return false if unsupported?

deprecated_versions.include?(version)
end

# Checks if the current version is unsupported.
# @example
# package_manager.unsupported? #=> false
# unsupported? #=> false
sig { returns(T::Boolean) }
def unsupported?
return false if supported_versions.empty?
Expand Down Expand Up @@ -124,7 +123,7 @@ def raise_if_unsupported!
# Indicates if the package manager supports later versions beyond those listed in supported_versions.
# By default, returns false if not overridden in the subclass.
# @example
# package_manager.support_later_versions? #=> true
# support_later_versions? #=> true
sig { returns(T::Boolean) }
def support_later_versions?
false
Expand All @@ -135,61 +134,60 @@ class Requirement
extend T::Sig

# Initialize version requirements with optional raw strings and parsed versions.
# @param req_raw [T.nilable(String)] the raw version requirements.
# @param req_raw_min [T.nilable(String)] the raw minimum version requirement.
# @param req_min [T.nilable(Dependabot::Version)] the parsed minimum version requirement.
# @param req_raw_max [T.nilable(String)] the raw maximum version requirement.
# @param req_max [T.nilable(Dependabot::Version)] the parsed maximum version requirement.
# @param raw_constraint [T.nilable(String)] the raw version constraint (e.g., ">= 2.0").
# @param min_raw_version [T.nilable(String)] the raw minimum version requirement (e.g., "2.0").
# @param min_version [T.nilable(Dependabot::Version)] the parsed minimum version.
# @param max_raw_version [T.nilable(String)] the raw maximum version requirement (e.g., "3.0").
# @param max_version [T.nilable(Dependabot::Version)] the parsed maximum version.
# @example
# Requirement.new(">= 2.0", "2.0", Version.new("2.0"), "3.0", Version.new("3.0"))
sig do
params(
req_raw: T.nilable(String),
req_raw_min: T.nilable(String),
req_min: T.nilable(Dependabot::Version),
req_raw_max: T.nilable(String),
req_max: T.nilable(Dependabot::Version)
raw_constraint: T.nilable(String),
min_raw_version: T.nilable(String),
min_version: T.nilable(Dependabot::Version),
max_raw_version: T.nilable(String),
max_version: T.nilable(Dependabot::Version)
).void
end
def initialize(
req_raw,
req_raw_min,
req_min,
req_raw_max,
req_max
raw_constraint: nil,
min_raw_version: nil,
min_version: nil,
max_raw_version: nil,
max_version: nil
)
# Ensure the type is correctly assigned to nullable types
@req_raw = T.let(req_raw, T.nilable(String))
@req_raw_min = T.let(req_raw_min, T.nilable(String))
@req_min = T.let(req_min, T.nilable(Dependabot::Version)) # Correctly inferred as nilable version
@req_raw_max = T.let(req_raw_max, T.nilable(String))
@req_max = T.let(req_max, T.nilable(Dependabot::Version)) # Correctly inferred as nilable version
@raw_constraint = T.let(raw_constraint, T.nilable(String))
@min_raw_version = T.let(min_raw_version, T.nilable(String))
@min_version = T.let(min_version, T.nilable(Dependabot::Version))
@max_raw_version = T.let(max_raw_version, T.nilable(String))
@max_version = T.let(max_version, T.nilable(Dependabot::Version))
end

# The raw version requirement.
# The raw version constraint (e.g., ">= 2.0").
sig { returns(T.nilable(String)) }
attr_reader :req_raw
attr_reader :raw_constraint

# The raw minimum version requirement.
# The raw minimum version requirement (e.g., "2.0").
sig { returns(T.nilable(String)) }
attr_reader :req_raw_min
attr_reader :min_raw_version

# The parsed minimum version requirement.
# The parsed minimum version.
sig { returns(T.nilable(Dependabot::Version)) }
attr_reader :req_min
attr_reader :min_version

# The raw maximum version requirement.
# The raw maximum version requirement (e.g., "3.0").
sig { returns(T.nilable(String)) }
attr_reader :req_raw_max
attr_reader :max_raw_version

# The parsed maximum version requirement.
# The parsed maximum version.
sig { returns(T.nilable(Dependabot::Version)) }
attr_reader :req_max
attr_reader :max_version
end

# Initialize with mandatory name and optional language information.
# @param name [String] the name of the name (e.g., "bundler", "npm_and_yarn").
# @param package_manager [VersionManager] the package manager
# @param name [String] the name of the ecosystem (e.g., "bundler", "npm_and_yarn").
# @param package_manager [VersionManager] the package manager.
# @param language [T.nilable(VersionManager)] optional language version information.
sig do
params(
Expand All @@ -208,21 +206,21 @@ def initialize(
@language = T.let(language, T.nilable(VersionManager))
end

# The name of the name (mandatory).
# The name of the ecosystem (mandatory).
# @example
# name #=> "npm_and_yarn"
sig { returns(String) }
attr_reader :name

# The information related to the package manager (mandatory).
# @example
# package_manager #=> VersionInformation.new("bundler", "2.1.4", Version.new("2.1.4"), nil)
# package_manager #=> VersionManager.new("bundler", "2.1.4", Version.new("2.1.4"), nil)
sig { returns(VersionManager) }
attr_reader :package_manager

# The version information of the language (optional).
# @example
# language #=> VersionInformation.new("ruby", "3.0.0", Version.new("3.0.0"), nil)
# language #=> VersionManager.new("ruby", "3.0.0", Version.new("3.0.0"), nil)
sig { returns(T.nilable(VersionManager)) }
attr_reader :language

Expand Down

0 comments on commit 5b5a020

Please sign in to comment.