php-composer 0.4.5 → 1.0.0.pre.alpha11

data/lib/composer/package/root_alias_package.rb

@@ -12,26 +12,197 @@
 module Composer
   module Package
 
-    # The root package represents the project's composer.json
-    # and contains additional metadata
-    class RootAliasPackage < Composer::Package::CompletePackage
+    ##
+    # The root alias package represents the project's composer.json
+    # and contains additional metadata.
+    ##
+    class RootAliasPackage < ::Composer::Package::AliasPackage
 
-      attr_accessor :minimum_stability, :prefer_stable, :stability_flags,
-                    :references, :aliases
+      ##
+      # Creates a new root alias package.
+      #
+      # Params:
+      # @param alias_of ::Composer::Package::Package
+      #   The package this package is an alias of.
+      # @param version string
+      #   The version the alias must report.
+      # @param pretty_version string
+      #   The alias's non-normalized version.
+      ##
+      def initialize(alias_of, version, pretty_version)
+        unless ::Composer::Package::ROOT_PACKAGE_INTERFACE.all? { |m| alias_of.respond_to?(m) }
+          raise ArgumentError,
+                %q("alias_of" must implement all methods defined in ROOT_PACKAGE_INTERFACE)
+        end
+        super(alias_of, version, pretty_version)
+      end
+
+      ##
+      # Returns a set of package names and their aliases.
+      # @return array
+      ##
+      def aliases
+        alias_of.aliases
+      end
+
+      ##
+      # Returns the minimum stability of the package.
+      # @return string
+      ##
+      def minimum_stability
+        alias_of.minimum_stability
+      end
+
+      ##
+      # Returns the stability flags to apply to dependencies.
+      #
+      # array('foo/bar' => 'dev')
+      #
+      # @return array
+      ##
+      def stability_flags
+        alias_of.stability_flags
+      end
+
+      ##
+      # Returns a set of package names and source references that must be enforced on them.
+      #
+      # array('foo/bar' => 'abcd1234')
+      #
+      # @return array
+      ##
+      def references
+        alias_of.references
+      end
+
+      ##
+      # Returns true if the root package prefers picking stable packages over unstable ones.
+      # @return bool
+      ##
+      def prefer_stable?
+        alias_of.prefer_stable?
+      end
+
+      ##
+      # Set the required packages.
+      #
+      # @param requires array
+      #   A set of package links.
+      ##
+      def requires=(requires)
+        @requires = replace_self_version_dependencies(requires, 'requires')
+        alias_of.requires = requires
+      end
+
+      ##
+      # Set the recommended packages.
+      #
+      # @param dev_requires array
+      #   A set of package links.
+      ##
+      def dev_requires=(dev_requires)
+        @dev_requires = replace_self_version_dependencies(dev_requires, 'devRequires')
+        alias_of.dev_requires = dev_requires
+      end
 
-      # Creates a new root package in memory package.
-      # Param: string name          The package's name
-      # Param: string version       The package's version
-      # Param: string prettyVersion The package's non-normalized version
-      def initialize(name, version, pretty_version)
-        super(name, version, pretty_version)
+      ##
+      # Set the conflicting packages.
+      #
+      # @param conflicts array
+      #   A set of package links.
+      ##
+      def conflicts=(conflicts)
+        @conflicts = replace_self_version_dependencies(conflicts, 'conflicts')
+        alias_of.conflicts = conflicts
+      end
 
-        @minimum_stability = 'stable'
-        @stability_flags = []
-        @references = []
-        @aliases = []
+      ##
+      # Set the provided virtual packages.
+      #
+      # @param provides array
+      #   A set of package links.
+      ##
+      def provides=(provides)
+        @provides = replace_self_version_dependencies(provides, 'provides')
+        alias_of.provides = provides
       end
 
+      ##
+      # Set the packages this one replaces.
+      #
+      # @param replaces array
+      #   A set of package links.
+      ##
+      def replaces=(replaces)
+        @replaces = replace_self_version_dependencies(replaces, 'replaces')
+        alias_of.replaces = replaces
+      end
+
+      ##
+      # Set the repositories.
+      #
+      # @param repositories array
+      #   A set of package links.
+      ##
+      def repositories=(repositories)
+        alias_of.repositories = repositories
+      end
+
+      ##
+      # Set the autoload mapping.
+      #
+      # @param autoload array
+      #   An array of autoloaded packages.
+      ##
+      def autoload=(autoload)
+        alias_of.autoload(autoload);
+      end
+
+      ##
+      # Set the dev autoload mapping.
+      #
+      # @param dev_autoload array
+      #   An array of dev autoloaded packages.
+      ##
+      def dev_autoload=(dev_autoload)
+        alias_of.dev_autoload(dev_autoload)
+      end
+
+      ##
+      # Set the stability flags.
+      #
+      # @param stability_flags array
+      #   An array of stability flags.
+      ##
+      def stability_flags=(stability_flags)
+        alias_of.stability_flags(stability_flags)
+      end
+
+      ##
+      # Set the package suggested packages.
+      #
+      # @param suggests array
+      #   An array of suggested packages.
+      ##
+      def suggests=(suggests)
+        alias_of.suggests(suggests)
+      end
+
+      ##
+      # Set the package extra packages.
+      #
+      # @param extra array
+      #   An array of extra packages.
+      ##
+      def extra=(extra)
+        alias_of.extra(extra)
+      end
+
+      # def __clone
+      #     parent::__clone;
+      # this->aliasOf = clone this->aliasOf;
+      # end
+
     end
   end
 end

data/lib/composer/package/root_package.rb

@@ -12,17 +12,25 @@
 module Composer
   module Package
 
+    ##
     # The root package represents the project's composer.json
     # and contains additional metadata
-    class RootPackage < Composer::Package::CompletePackage
+    ##
+    class RootPackage < ::Composer::Package::CompletePackage
 
       attr_accessor :minimum_stability, :prefer_stable, :stability_flags,
                     :references, :aliases
 
+      ##
       # Creates a new root package in memory package.
-      # Param: string name          The package's name
-      # Param: string version       The package's version
-      # Param: string prettyVersion The package's non-normalized version
+      #
+      # @param name string name
+      #   The package's name
+      # @param version string version
+      #   The package's version
+      # @param: pretty_version string
+      #   The package's non-normalized version
+      ##
       def initialize(name, version, pretty_version)
         super(name, version, pretty_version)
 

data/lib/composer/package/version/version_parser.rb

@@ -1,17 +1,23 @@
-#
+##
 # This file was ported to ruby from Composer php source code file.
+#
 # Original Source: Composer\Package\Version\VersionParser.php
+# Ref SHA: 1328d9c3b2fbe2d71079c5009b2d5204ce956c2e
 #
 # (c) Nils Adermann <naderman@naderman.de>
 #     Jordi Boggiano <j.boggiano@seld.be>
 #
 # For the full copyright and license information, please view the LICENSE
 # file that was distributed with this source code.
-#
+##
+
+require 'composer/semver'
 
 module Composer
   module Package
     module Version
+
+      ##
       # Version Parser
       #
       # PHP Authors:
@@ -19,299 +25,19 @@ module Composer
       #
       # Ruby Authors:
       # Ioannis Kappas <ikappas@devworks.gr>
-      class VersionParser
-        MODIFIER_REGEX = '[._-]?(?:(stable|beta|b|RC|alpha|a|patch|pl|p)(?:[.-]?(\d+))?)?([.-]?dev)?'.freeze()
-
-        class << self
-
-          # Returns the stability of a version
-          #
-          # Params:
-          # +version+:: string The version to parse for stability
-          #
-          # Returns:
-          # string The version's stability
-          def parse_stability(version)
-            raise ArgumentError, 'version must be specified' unless version
-            raise TypeError, 'version must be of type String' unless version.is_a?(String)
-            raise UnexpectedValueError, 'version string must not be empty' if version.empty?
-
-            version = version.gsub(/#.+$/i, '')
-
-            if version.start_with?('dev-') || version.end_with?('-dev')
-              return 'dev'
-            end
-
-            if matches = /#{MODIFIER_REGEX}$/i.match(version.downcase)
-              if matches[3]
-                return 'dev'
-              elsif matches[1]
-                if 'beta' === matches[1] || 'b' === matches[1]
-                  return 'beta'
-                elsif 'alpha' === matches[1] || 'a' === matches[1]
-                  return 'alpha'
-                elsif 'rc' === matches[1]
-                  return 'RC'
-                end
-              end
-            end
-
-            'stable'
-          end
-
-          # Normalize the specified stability
-          # Param: string stability
-          # Return: string
-          def normalize_stability(stability)
-            raise ArgumentError, 'stability must be specified' unless stability
-            raise TypeError, 'stability must be of type String' unless stability.is_a?(String)
-            stability = stability.downcase
-            stability === 'rc' ? 'RC' : stability
-          end
-
-          # Formats package version
-          # Param: Composer::Package::Package package
-          # Param: boolean truncate
-          # Return: string
-          def format_version(package, truncate = true)
-            if !package.is_dev || !['hg', 'git'].include?(package.source_type)
-              return package.pretty_version
-            end
-
-            # if source reference is a sha1 hash -- truncate
-            if truncate && package.source_reference.length === 40
-              return "#{package.pretty_version} #{package.source_reference[0..6]}"
-            end
-
-            "#{package.pretty_version} #{package.source_reference}"
-          end
-        end
-
-        # Normalizes a version string to be able to perform comparisons on it
-        #
-        # Params:
-        # +version+:: <tt>String</tt> The version string to normalize
-        # +full_version+:: <tt>String</tt> optional complete version string to
-        #                  give more context
-        #
-        # Throws:
-        #   +InvalidVersionStringError+
-        #
-        # Returns:
-        #   +String+
-        def normalize(version, full_version = nil)
-          raise ArgumentError, 'version must be specified' unless version
-          raise TypeError, 'version must be of type String' unless version.is_a?(String)
-          raise UnexpectedValueError, 'version string must not be empty' if version.empty?
-
-          version.strip!
-          if full_version == nil
-            full_version = version
-          end
-
-          # ignore aliases and just assume the alias is required
-          # instead of the source
-          if matches = /^([^,\s]+) +as +([^,\s]+)$/.match(version)
-            version = matches[1]
-          end
-
-          # ignore build metadata
-          if matches = /^([^,\s+]+)\+[^\s]+$/.match(version)
-            version = matches[1]
-          end
-
-          # match master-like branches
-          if matches = /^(?:dev-)?(?:master|trunk|default)$/i.match(version)
-            return '9999999-dev'
-          end
-
-          if 'dev-' === version[0...4].downcase
-            return "dev-#{version[4..version.size]}"
-          end
-
-          # match classical versioning
-          index = 0
-          if matches = /^v?(\d{1,3})(\.\d+)?(\.\d+)?(\.\d+)?#{MODIFIER_REGEX}$/i.match(version)
-            version = ''
-            matches.to_a[1..4].each do |c|
-              version += c ? c : '.0'
-            end
-            index = 5
-          elsif matches = /^v?(\d{4}(?:[.:-]?\d{2}){1,6}(?:[.:-]?\d{1,3})?)#{MODIFIER_REGEX}$/i.match(version)
-            version = matches[1].gsub(/\D/, '-')
-            index = 2
-          elsif matches = /^v?(\d{4,})(\.\d+)?(\.\d+)?(\.\d+)?#{MODIFIER_REGEX}$/i.match(version)
-            version = ''
-            matches.to_a[1..4].each do |c|
-              version << (c.nil? ? '.0' : c)
-            end
-            index = 5
-          end
-
-          # add version modifiers if a version was matched
-          if index > 0
-            if matches[index]
-              if 'stable' === matches[index]
-                return version
-              end
-              stability = expand_stability(matches[index])
-              version = "#{version}-#{stability ? stability : matches[index]}#{matches[index + 1] ? matches[index + 1] : ''}"
-            end
-
-            if matches[index + 2]
-              version = "#{version}-dev"
-            end
-
-            return version
-          end
-
-          # match dev branches
-          if matches = /(.*?)[.-]?dev$/i.match(version)
-            begin
-              return normalize_branch(matches[1])
-            rescue
-            end
-          end
-
-          extra_message = ''
-          if matches = / +as +#{Regexp.escape(version)}$/.match(full_version)
-            extra_message = " in \"#{full_version}\", the alias must be an exact version"
-          elsif matches = /^#{Regexp.escape(version)} +as +/.match(full_version)
-            extra_message = " in \"#{full_version}\", the alias source must be an exact version, if it is a branch name you should prefix it with dev-"
-          end
-
-          raise UnexpectedValueError, "Invalid version string \"#{version}\"#{extra_message}"
-        end
-
-        # Normalizes a branch name to be able to perform comparisons on it
-        #
-        # Params:
-        # +name+:: string The branch name to normalize
-        #
-        # Returns:
-        # string The normalized branch name
-        def normalize_branch(name)
-          name.strip!
-
-          if ['master', 'trunk', 'default'].include?(name)
-            return normalize(name)
-          end
-
-          if matches = /^v?(\d+)(\.(?:\d+|[xX*]))?(\.(?:\d+|[xX*]))?(\.(?:\d+|[xX*]))?$/i.match(name)
-            version = ''
-
-            # for i in 0..3
-            #   # version << matches[i] ? matches[i].gsub('*', 'x').gsub('X', 'x') : '.x'
-            # end
-            matches.captures.each { |match| version << (match != nil ? match.gsub('*', 'x').gsub('X', 'x') : '.x') }
-            return "#{version.gsub('x', '9999999')}-dev"
-          end
-
-          "dev-#{name}"
-        end
-
-        # Params:
-        # +source+:: string source package name
-        # +source_version+:: string source package version (pretty version ideally)
-        # +description+:: string link description (e.g. requires, replaces, ..)
-        # +links+:: array An array of package name => constraint mappings
-        #
-        # Returns:
-        # Link[]
-        def parse_links(source, source_version, description, links)
-          res = {}
-          links.each do |target, constraint|
-            if 'self.version' === constraint
-              parsed_constraint = parse_constraints(source_version)
-            else
-              parsed_constraint = parse_constraints(constraint)
-            end
-            res[target.downcase] = Composer::Package::Link.new(
-              source,
-              target,
-              parsed_constraint,
-              description,
-              constraint
-            )
-          end
-          res
-        end
-
-        def parse_constraints(constraints)
-          raise ArgumentError, 'version must be specified' unless constraints
-          raise TypeError, 'version must be of type String' unless constraints.is_a?(String)
-          raise UnexpectedValueError, 'version string must not be empty' if constraints.empty?
-
-          pretty_constraint = constraints
-
-          stabilites = Composer::Package::BasePackage.stabilities.keys.join('|')
-          if match = /^([^,\s]*?)@(#{stabilites})$/i.match(constraints)
-            constraints = match[1].nil? || match[1].empty? ? '*' : match[1]
-          end
-
-          if match = /^(dev-[^,\s@]+?|[^,\s@]+?\.x-dev)#.+$/i.match(constraints)
-            constraints = match[1]
-          end
-
-          # or_constraints = preg_split('{\s*\|\|?\s*}', trim(constraints))
-          or_constraints = constraints.strip.split(/\s*\|\|?\s*/)
-          or_groups = []
-          or_constraints.each do |constraints|
-
-            # and_constraints = preg_split('{(?<!^|as|[=>< ,]) *(?<!-)[, ](?!-) *(?!,|as|$)}', constraints)
-            and_constraints = constraints.split(/(?<!^|as|[=>< ,]) *(?<!-)[, ](?!-) *(?!,|as|$)/)
-
-            if and_constraints.length > 1
-                constraint_objects = []
-                and_constraints.each do |constraint|
-                  constraint_objects << parse_constraint(constraint)
-                end
-            else
-              constraint_objects = parse_constraint(and_constraints[0])
-            end
-
-            if constraint_objects.length === 1
-              constraint = constraint_objects[0]
-            else
-              constraint = Composer::Package::LinkConstraint::MultiConstraint.new(constraint_objects)
-            end
-
-            or_groups << constraint
-          end
-
-          if or_groups.length === 1
-            constraint = or_groups[0]
-          else
-            constraint = Composer::Package::LinkConstraint::MultiConstraint.new(or_groups, false)
-          end
-
-          constraint.pretty_string = pretty_constraint
-
-          constraint
-        end
-
-        # Extract numeric prefix from alias, if it is in numeric format,
-        # suitable for version comparison
-        #
-        # Params:
-        # +branch+:: string Branch name (e.g. 2.1.x-dev)
-        #
-        # Returns:
-        # string|false Numeric prefix if present (e.g. 2.1.) or false
-        def parse_numeric_alias_prefix(branch)
-          if matches = /^(?<version>(\d+\.)*\d+)(?:\.x)?-dev$/i.match(branch)
-            return "#{matches['version']}."
-          end
-          false
-        end
+      ##
+      class VersionParser < ::Composer::Semver::VersionParser
 
+        ##
         # Parses a name/version pairs and returns an array of pairs + the
         #
         # Params:
-        # +pairs+:: array a set of package/version pairs separated by ":", "=" or " "
+        # @param pairs
+        #   a set of package/version pairs separated by ":", "=" or " "
         #
-        # Returns:
-        # array[] array of arrays containing a name and (if provided) a version
+        # @return array[]
+        #   An array of arrays containing a name and (if provided) a version
+        ##
         def parse_name_version_pairs(pairs)
           pairs = pairs.values
           result = []
@@ -335,248 +61,6 @@ module Composer
           result
         end
 
-        # PRIVATE METHODS
-        private
-
-        def parse_constraint(constraint)
-
-          stabilites = Composer::Package::BasePackage.stabilities.keys.join('|')
-          if match = /^([^,\s]+?)@(#{stabilites})$/i.match(constraint)
-            constraint = match[1]
-            if match[2] != 'stable'
-              stability_modifier = match[2]
-            end
-          end
-
-          if /^[xX*](\.[xX*])*$/i.match(constraint)
-            return [
-              Composer::Package::LinkConstraint::EmptyConstraint.new
-            ]
-          end
-
-          version_regex = '(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?' + MODIFIER_REGEX
-
-          # match tilde constraints
-          # like wildcard constraints, unsuffixed tilde constraints say that they must be greater than the previous
-          # version, to ensure that unstable instances of the current version are allowed.
-          # however, if a stability suffix is added to the constraint, then a >= match on the current version is
-          # used instead
-          if matches = /^~>?#{version_regex}$/i.match(constraint)
-
-            if constraint[0...2] === '~>'
-              raise UnexpectedValueError,
-                  "Could not parse version constraint #{constraint}: \
-                  Invalid operator \"~>\", you probably meant to use the \"~\" operator"
-            end
-
-            # Work out which position in the version we are operating at
-            if matches[4] && matches[4] != ''
-                position = 4
-            elsif matches[3] && matches[3] != ''
-                position = 3
-            elsif matches[2] && matches[2] != ''
-                position = 2
-            else
-                position = 1
-            end
-
-            # Calculate the stability suffix
-            stability_suffix = ''
-            if !matches[5].nil? && !matches[5].empty?
-              stability_suffix << "-#{expand_stability(matches[5])}"
-              if !matches[6].nil? && !matches[6].empty?
-                stability_suffix << matches[6]
-              end
-            end
-
-            if !matches[7].nil? && !matches[7].empty?
-              stability_suffix << '-dev'
-            end
-
-            stability_suffix = '-dev' if stability_suffix.empty?
-
-            low_version = manipulate_version_string(matches.to_a, position, 0) + stability_suffix
-            lower_bound = Composer::Package::LinkConstraint::VersionConstraint.new('>=', low_version)
-
-            # For upper bound, we increment the position of one more significance,
-            # but high_position = 0 would be illegal
-            high_position = [1, position - 1].max
-            high_version = manipulate_version_string(matches.to_a, high_position, 1) + '-dev'
-            upper_bound = Composer::Package::LinkConstraint::VersionConstraint.new('<', high_version)
-
-            return [
-              lower_bound,
-              upper_bound
-            ]
-          end
-
-          # match caret constraints
-          if matches = /^\^#{version_regex}($)/i.match(constraint)
-            # Create comparison array
-            has_match = []
-            for i in 0..(matches.to_a.length - 1)
-              has_match[i] = !matches[i].nil? && !matches[i].empty?
-            end
-
-            # Work out which position in the version we are operating at
-            if matches[1] != '0' || !has_match[2]
-              position = 1
-            elsif matches[2] != '0' || !has_match[3]
-              position = 2
-            else
-              position = 3
-            end
-
-            # Calculate the stability suffix
-            stability_suffix = ''
-            if !has_match[5] && !has_match[7]
-              stability_suffix << '-dev'
-            end
-
-            low_pretty = "#{constraint}#{stability_suffix}"
-            low_version = normalize(low_pretty[1..low_pretty.length - 1])
-            lower_bound = Composer::Package::LinkConstraint::VersionConstraint.new('>=', low_version)
-
-            # For upper bound, we increment the position of one more significance,
-            # but high_position = 0 would be illegal
-            high_version = manipulate_version_string(matches.to_a, position, 1) + '-dev'
-            upper_bound = Composer::Package::LinkConstraint::VersionConstraint.new('<', high_version)
-
-            return [
-              lower_bound,
-              upper_bound
-            ]
-          end
-
-          # match wildcard constraints
-          if matches = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?\.[xX*]$/.match(constraint)
-            if matches[3] && matches[3] != ''
-              position = 3
-            elsif matches[2] && matches[2] != ''
-              position = 2
-            else
-              position = 1
-            end
-
-            low_version = manipulate_version_string(matches.to_a, position) + '-dev'
-            high_version = manipulate_version_string(matches.to_a, position, 1) + '-dev'
-
-            if low_version === "0.0.0.0-dev"
-              return [Composer::Package::LinkConstraint::VersionConstraint.new('<', high_version)]
-            end
-
-            return [
-              Composer::Package::LinkConstraint::VersionConstraint.new('>=', low_version),
-              Composer::Package::LinkConstraint::VersionConstraint.new('<', high_version),
-            ]
-          end
-
-          # match hyphen constraints
-          if matches = /^(#{version_regex}) +- +(#{version_regex})($)/i.match(constraint)
-
-            match_from = matches[1]
-            match_to = matches[9]
-
-            # Create comparison array
-            has_match = []
-            for i in 0..(matches.to_a.length - 1)
-              has_match[i] = !matches[i].nil? && !matches[i].empty?
-            end
-
-            # Calculate the stability suffix
-            low_stability_suffix = ''
-            if !has_match[6] && !has_match[8]
-              low_stability_suffix = '-dev'
-            end
-
-            low_version = normalize(match_from)
-            lower_bound = Composer::Package::LinkConstraint::VersionConstraint.new('>=', low_version + low_stability_suffix)
-
-            # high_version = matches[10]
-
-            if (has_match[11] && has_match[12]) || has_match[14] || has_match[16]
-              high_version = normalize(match_to)
-              upper_bound = Composer::Package::LinkConstraint::VersionConstraint.new('<=', high_version)
-            else
-              high_match = ['', matches[10], matches[11], matches[12], matches[13]]
-              high_version = manipulate_version_string(high_match, (!has_match[11] ? 1 : 2), 1) + '-dev'
-              upper_bound = Composer::Package::LinkConstraint::VersionConstraint.new('<', high_version)
-            end
-
-            return [
-              lower_bound,
-              upper_bound
-            ]
-          end
-
-          # match operators constraints
-          if matches = /^(<>|!=|>=?|<=?|==?)?\s*(.*)/.match(constraint)
-            begin
-              version = normalize(matches[2])
-              stability = VersionParser::parse_stability(version)
-              if !stability_modifier.nil? && !stability_modifier.empty? && (stability === 'stable')
-                version << "-#{stability_modifier}"
-              elsif matches[1] === '<'
-                unless /-#{MODIFIER_REGEX}$/.match(matches[2].downcase)
-                  version << '-dev'
-                end
-              end
-              operator = matches[1].nil? ? '=' : matches[1]
-              return [Composer::Package::LinkConstraint::VersionConstraint.new(operator, version)]
-            rescue Exception => e
-            end
-          end
-
-          message = "Could not parse version constraint #{constraint}"
-          message << ": #{e.message}" if e
-          raise UnexpectedValueError, message
-        end
-
-        # Increment, decrement, or simply pad a version number.
-        # Support function for {@link parse_constraint()}
-        #
-        # Params:
-        # +matches+ Array with version parts in array indexes 1,2,3,4
-        # +position+ Integer 1,2,3,4 - which segment of the version to decrement
-        # +increment+ Integer
-        # +pad+ String The string to pad version parts after position
-        #
-        # Returns:
-        # string The new version
-        def manipulate_version_string(matches, position, increment = 0, pad = '0')
-          4.downto(1).each do |i|
-            if i > position
-              matches[i] = pad
-            elsif i == position && increment
-              matches[i] = matches[i].to_i + increment
-              # If matches[i] was 0, carry the decrement
-              if matches[i] < 0
-                matches[i] = pad
-                position -= 1
-
-                # Return nil on a carry overflow
-                return nil if i == 1
-              end
-            end
-          end
-          "#{matches[1]}.#{matches[2]}.#{matches[3]}.#{matches[4]}"
-        end
-
-        def expand_stability(stability)
-          stability = stability.downcase
-          case stability
-          when 'a'
-            'alpha'
-          when 'b'
-            'beta'
-          when 'p', 'pl'
-            'patch'
-          when 'rc'
-            'RC'
-          else
-            stability
-          end
-        end
       end
     end
   end