dependabot-core 0.78.0 → 0.79.0

data/lib/dependabot/utils/python/requirement.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "dependabot/utils/python/version"
-
-module Dependabot
-  module Utils
-    module Python
-      class Requirement < Gem::Requirement
-        OR_SEPARATOR = /(?<=[a-zA-Z0-9*])\s*\|+/.freeze
-
-        # Add equality and arbitrary-equality matchers
-        OPS["=="] = ->(v, r) { v == r }
-        OPS["==="] = ->(v, r) { v.to_s == r.to_s }
-
-        quoted = OPS.keys.sort_by(&:length).reverse.
-                 map { |k| Regexp.quote(k) }.join("|")
-        version_pattern = Utils::Python::Version::VERSION_PATTERN
-
-        PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{version_pattern})\\s*"
-        PATTERN = /\A#{PATTERN_RAW}\z/.freeze
-
-        def self.parse(obj)
-          if obj.is_a?(Gem::Version)
-            return ["=", Utils::Python::Version.new(obj.to_s)]
-          end
-
-          unless (matches = PATTERN.match(obj.to_s))
-            msg = "Illformed requirement [#{obj.inspect}]"
-            raise BadRequirementError, msg
-          end
-
-          return DefaultRequirement if matches[1] == ">=" && matches[2] == "0"
-
-          [matches[1] || "=", Utils::Python::Version.new(matches[2])]
-        end
-
-        # Returns an array of requirements. At least one requirement from the
-        # returned array must be satisfied for a version to be valid.
-        #
-        # NOTE: Or requirements are only valid for Poetry.
-        def self.requirements_array(requirement_string)
-          return [new(nil)] if requirement_string.nil?
-
-          requirement_string.strip.split(OR_SEPARATOR).map do |req_string|
-            new(req_string.strip)
-          end
-        end
-
-        def initialize(*requirements)
-          requirements = requirements.flatten.flat_map do |req_string|
-            next if req_string.nil?
-
-            req_string.split(",").map do |r|
-              convert_python_constraint_to_ruby_constraint(r)
-            end
-          end
-
-          super(requirements)
-        end
-
-        def satisfied_by?(version)
-          version = Utils::Python::Version.new(version.to_s)
-          super
-        end
-
-        def exact?
-          return false unless @requirements.size == 1
-
-          %w(= == ===).include?(@requirements[0][0])
-        end
-
-        private
-
-        def convert_python_constraint_to_ruby_constraint(req_string)
-          return nil if req_string.nil?
-          return nil if req_string == "*"
-
-          req_string = req_string.gsub("~=", "~>")
-          req_string = req_string.gsub(/(?<=\d)[<=>].*/, "")
-
-          if req_string.match?(/~[^>]/) then convert_tilde_req(req_string)
-          elsif req_string.start_with?("^") then convert_caret_req(req_string)
-          elsif req_string.include?(".*") then convert_wildcard(req_string)
-          else req_string
-          end
-        end
-
-        # Poetry uses ~ requirements.
-        # https://github.com/sdispater/poetry#tilde-requirements
-        def convert_tilde_req(req_string)
-          version = req_string.gsub(/^~\>?/, "")
-          parts = version.split(".")
-          parts << "0" if parts.count < 3
-          "~> #{parts.join('.')}"
-        end
-
-        # Poetry uses ^ requirements
-        # https://github.com/sdispater/poetry#caret-requirement
-        def convert_caret_req(req_string)
-          version = req_string.gsub(/^\^/, "")
-          parts = version.split(".")
-          parts = parts.fill(0, parts.length...3)
-          first_non_zero = parts.find { |d| d != "0" }
-          first_non_zero_index =
-            first_non_zero ? parts.index(first_non_zero) : parts.count - 1
-          upper_bound = parts.map.with_index do |part, i|
-            if i < first_non_zero_index then part
-            elsif i == first_non_zero_index then (part.to_i + 1).to_s
-            elsif i > first_non_zero_index && i == 2 then "0.a"
-            else 0
-            end
-          end.join(".")
-
-          [">= #{version}", "< #{upper_bound}"]
-        end
-
-        def convert_wildcard(req_string)
-          # Note: This isn't perfect. It replaces the "!= 1.0.*" case with
-          # "!= 1.0.0". There's no way to model this correctly in Ruby :'(
-          req_string.
-            split(".").
-            first(req_string.split(".").index("*") + 1).
-            join(".").
-            tr("*", "0").
-            gsub(/^(?<!!)=*/, "~>")
-        end
-      end
-    end
-  end
-end

data/lib/dependabot/utils/python/version.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-# Python versions can include a local version identifier, which Ruby can't
-# parser. This class augments Gem::Version with local version identifier info.
-# See https://www.python.org/dev/peps/pep-0440 for details.
-
-module Dependabot
-  module Utils
-    module Python
-      class Version < Gem::Version
-        attr_reader :local_version
-
-        VERSION_PATTERN = '[0-9]+[0-9a-zA-Z]*(?>\.[0-9a-zA-Z]+)*' \
-                          '(-[0-9A-Za-z-]+(\.[0-9a-zA-Z-]+)*)?' \
-                          '(\+[0-9a-zA-Z]+(\.[0-9a-zA-Z]+)*)?'
-        ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/.freeze
-
-        def self.correct?(version)
-          return false if version.nil?
-
-          version.to_s.match?(ANCHORED_VERSION_PATTERN)
-        end
-
-        def initialize(version)
-          @version_string = version.to_s
-          version, @local_version = version.split("+")
-          version ||= ""
-          version = normalise_prerelease(version)
-          if @local_version
-            @local_version = normalise_prerelease(@local_version)
-          end
-          super
-        end
-
-        def to_s
-          @version_string
-        end
-
-        def inspect # :nodoc:
-          "#<#{self.class} #{@version_string}>"
-        end
-
-        def <=>(other)
-          version_comparison = super(other)
-          return version_comparison unless version_comparison.zero?
-
-          unless other.is_a?(Utils::Python::Version)
-            return local_version.nil? ? 0 : 1
-          end
-
-          # Local version comparison works differently in Python: `1.0.beta`
-          # compares as greater than `1.0`. To accommodate, we make the
-          # strings the same length before comparing.
-          lhsegments = local_version.to_s.split(".").map(&:downcase)
-          rhsegments = other.local_version.to_s.split(".").map(&:downcase)
-          limit = [lhsegments.count, rhsegments.count].min
-
-          lhs = ["1", *lhsegments.first(limit)].join(".")
-          rhs = ["1", *rhsegments.first(limit)].join(".")
-
-          local_comparison = Gem::Version.new(lhs) <=> Gem::Version.new(rhs)
-
-          return local_comparison unless local_comparison.zero?
-
-          lhsegments.count <=> rhsegments.count
-        end
-
-        private
-
-        def normalise_prerelease(version)
-          # Python has reserved words for release states, which are treated
-          # as equal (e.g., preview, pre and rc).
-          # Further, Python treats dashes as a separator between version
-          # parts and treats the alphabetical characters in strings as the
-          # start of a new version part (so 1.1a2 == 1.1.alpha.2).
-          version.
-            gsub("alpha", "a").
-            gsub("beta", "b").
-            gsub("preview", "rc").
-            gsub("pre", "rc").
-            gsub(/([\d.\-_])c([\d.\-_])?/, '\1rc\2').
-            tr("-", ".").
-            gsub(/(\d)([a-z])/i, '\1.\2')
-        end
-      end
-    end
-  end
-end

data/lib/python_requirement_parser.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class PythonRequirementParser
-  NAME = /[a-zA-Z0-9\-_\.]+/.freeze
-  EXTRA = /[a-zA-Z0-9\-_\.]+/.freeze
-  COMPARISON = /===|==|>=|<=|<|>|~=|!=/.freeze
-  VERSION = /[0-9]+[a-zA-Z0-9\-_\.*]*(\+[0-9a-zA-Z]+(\.[0-9a-zA-Z]+)*)?/.freeze
-  REQUIREMENT =
-    /(?<comparison>#{COMPARISON})\s*\\?\s*(?<version>#{VERSION})/.freeze
-  HASH = /--hash=(?<algorithm>.*?):(?<hash>.*?)(?=\s|$)/.freeze
-  REQUIREMENTS = /#{REQUIREMENT}(\s*,\s*\\?\s*#{REQUIREMENT})*/.freeze
-  HASHES = /#{HASH}(\s*\\?\s*#{HASH})*/.freeze
-
-  INSTALL_REQ_WITH_REQUIREMENT =
-    /\s*\\?\s*(?<name>#{NAME})
-      \s*\\?\s*(\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-      \s*\\?\s*(?<requirements>#{REQUIREMENTS})
-      \s*\\?\s*(?<hashes>#{HASHES})?
-      \s*#*\s*(?<comment>.+)?
-    /x.freeze
-
-  INSTALL_REQ_WITHOUT_REQUIREMENT =
-    /^\s*\\?\s*(?<name>#{NAME})
-      \s*\\?\s*(\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-      \s*\\?\s*(?<hashes>#{HASHES})?
-      \s*#*\s*(?<comment>.+)?$
-    /x.freeze
-
-  NAME_WITH_EXTRAS =
-    /\s*\\?\s*(?<name>#{NAME})
-      (\s*\\?\s*\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-    /x.freeze
-end

data/lib/python_versions.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module PythonVersions
-  # Poetry doesn't handle Python versions, so we have to do so manually
-  # (checking from a list of versions Poetry supports).
-  # This list gets iterated through to find a valid version, so we have
-  # the two pre-installed versions listed first.
-  PYTHON_VERSIONS = %w(
-    3.6.7 2.7.15
-    3.7.1 3.7.0
-    3.6.7 3.6.6 3.6.5 3.6.4 3.6.3 3.6.2 3.6.1 3.6.0
-    3.5.6 3.5.5 3.5.4 3.5.3 3.5.2 3.5.1 3.5.0
-    3.4.9 3.4.8 3.4.7 3.4.6 3.4.5 3.4.4 3.4.3 3.4.2 3.4.1 3.4.0
-    2.7.15 2.7.14 2.7.13 2.7.12 2.7.11 2.7.10 2.7.9 2.7.8 2.7.7 2.7.6 2.7.5
-    2.7.4 2.7.3 2.7.2 2.7.1 2.7
-  ).freeze
-
-  PRE_INSTALLED_PYTHON_VERSIONS = %w(
-    3.6.7 2.7.15
-  ).freeze
-end