php-composer 0.1.0

data/lib/composer/package/loader/json_loader.rb

@@ -0,0 +1,47 @@
+#
+# This file was ported to ruby from Composer php source code.
+# Original Source: Composer\Package\Loader\JsonLoader.php
+#
+# (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.
+#
+
+module Composer
+  module Package
+    module Loader
+
+      # Loads a package from a json string or JsonFile
+      # @author Ioannis Kappas <ikappas@devworks.gr>
+      # @php_author Konstantin Kudryashiv <ever.zet@gmail.com>
+      class JsonLoader
+
+        def initialize(loader)
+          @loader = loader
+        end
+
+        # Load a json string or file
+        # Param:  string|JsonFile json A filename, json string or JsonFile instance to load the package from
+        # Returns: Composer::Package::Package
+        def load(json)
+          if json.instance_of?(Composer::Json::JsonFile)
+            config = json.read
+          elsif File.exist?(json)
+            config = Composer::Json::JsonFile.parse_json(
+              File.open(filepath, "r") { |f| f.read },
+              json
+            )
+          elsif json.class === "String"
+            config = Composer::Json::JsonFile.parse_json(
+              json
+            )
+          end
+          @loader.load(config)
+        end
+
+      end
+    end
+  end
+end

data/lib/composer/package/loader/project_attributes_loader.rb

@@ -0,0 +1,71 @@
+require 'digest/crc32'
+
+module Composer
+  module Package
+    module Loader
+
+      # Loads a package from project attributes
+      # @author Ioannis Kappas <ikappas@devworks.gr>
+      class ProjectAttributesLoader
+
+        def initialize(loader)
+          @loader = loader
+        end
+
+        # Load a json string or file
+        # Param:  string|JsonFile json A filename, json string or JsonFile instance to load the package from
+        # Returns: Composer::Package::Package
+        def load(project, ref, type = 'library')
+
+          version = (ref.instance_of?(Gitlab::Git::Branch)) ? "dev-#{ref.name}" : ref.name
+
+          config = {
+            'name'                => project.path_with_namespace.gsub(/\s/, '').downcase,
+            'description'         => project.description,
+            'version'             => version,
+            'uid'                 => Digest::CRC32.checksum(ref.name + ref.target),
+            'source'              => {
+              'url'                 => project.url_to_repo,
+              'type'                => 'git',
+              'reference'           => ref.target
+            },
+            'dist'                => {
+              'url'                 => [project.web_url, 'repository', 'archive.zip?ref=' + ref.name].join('/'),
+              'type'                => 'zip'
+            },
+            'type'                => type,
+            'homepage'            => project.web_url
+          }
+
+          if time = get_time(project, ref)
+            log("Ref: #{ref.to_json} Time: #{time}")
+            config['time'] = time
+          end
+
+          if keywords = get_keywords(project)
+            config['keywords'] = keywords
+          end
+
+          @loader.load(config)
+        end
+
+        private
+
+        def get_time(project, ref)
+          commit = project.repository.commit(ref.target)
+          commit.committed_date.strftime('%Y-%m-%d %H:%M:%S')
+        rescue
+          # If there's a problem, just skip the "time" field
+        end
+
+        def get_keywords(project)
+          project.tags.collect { |t| t['name'] }
+        end
+
+        def log(message)
+          Gitlab::AppLogger.error("ComposerService: #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/composer/package/loader/project_root_package_loader.rb

@@ -0,0 +1,28 @@
+module Composer
+  module Package
+    module Loader
+
+      # Loads a package from the project root package
+      # @author Ioannis Kappas <ikappas@devworks.gr>
+      class ProjectRootPackageLoader
+
+        def initialize(loader)
+          @loader = loader
+        end
+
+        # Load a project ref
+        # Param:  string|JsonFile json A filename, json string or JsonFile instance to load the package from
+        # Returns: Composer::Package::Package
+        def load(project, ref)
+
+          config = Composer::Json::JsonFile.parse_json(
+            project.repository.blob_at(ref.target, 'composer.json')
+          )
+
+          @loader.load(config)
+        end
+
+      end
+    end
+  end
+end

data/lib/composer/package/package.rb

@@ -0,0 +1,118 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\Package.php
+#
+# (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 'digest/crc32'
+
+module Composer
+  module Package
+
+    # Core package definitions that are needed to resolve dependencies
+    # and install packages
+    class Package < Composer::Package::BasePackage
+
+      attr_reader :stability
+
+      attr_accessor :installation_source, :source_type,
+                    :source_url, :source_reference, :source_mirrors, :dist_type,
+                    :dist_url, :dist_reference, :dist_sha1_checksum,
+                    :dist_mirrors, :release_date, :extra, :binaries, :requires,
+                    :conflicts, :provides, :replaces, :dev_requires, :suggests,
+                    :autoload, :dev_autoload, :include_paths, :archive_excludes,
+                    :notification_url
+
+      # complete package attributes
+
+
+      # Creates a new 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)
+
+        # default values
+        @extra = {}
+        @binaries = []
+        @requires = {}
+        @conflicts = {}
+        @provides = {}
+        @replaces = {}
+        @dev_requires = {}
+        @suggests = {}
+        @autoload = {}
+        @dev_autoload = {}
+        @include_paths = []
+        @archive_excludes = []
+
+        # init package attributes
+        replace_version(version, pretty_version)
+
+      end
+
+      def attributes
+        dumper = Composer::Package::Dumper::HashDumper.new
+        dumper.dump(self)
+      end
+
+      # Set package type
+      # Param: string type
+      def type=(type)
+        @type = type
+      end
+
+      # Get package type
+      # Return: string
+      def type
+        @type ? @type : 'library'
+      end
+
+      def target_dir=(target_dir)
+        @target_dir = target_dir
+      end
+
+      def target_dir
+        return unless @target_dir
+        regex = '(?:^|[\\\\/]+)\.\.?(?:[\\\\/]+|$)(?:\.\.?(?:[\\\\/]+|$))*'
+        @target_dir.gsub(/#{regex}/x, '/').gsub(/^\/+/, '')
+      end
+
+      # Returns package unique name, constructed from name, version and
+      # release type.
+      # Return: string
+      def unique_name
+        "#{name}-#{version}"
+      end
+
+      def pretty_string
+        "#{pretty_name} #{pretty_version}"
+      end
+
+      # Determine if development package
+      # Return: true if development package; Otherwise false.
+      def is_dev
+        @dev
+      end
+
+      # Replaces current version and pretty version with passed values.
+      # It also sets stability.
+      # Param: string version       The package's normalized version
+      # Param: string prettyVersion The package's non-normalized version
+      def replace_version(version, pretty_version)
+        @version = version
+        @pretty_version = pretty_version
+
+        @stability = Composer::Package::Version::VersionParser::parse_stability(version)
+        @dev = @stability === 'dev'
+      end
+
+    end
+  end
+end

data/lib/composer/package/root_alias_package.rb

@@ -0,0 +1,37 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\RootAliasPackage.php
+#
+# (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.
+#
+
+module Composer
+  module Package
+
+    # The root package represents the project's composer.json
+    # and contains additional metadata
+    class RootAliasPackage < 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
+      def initialize(name, version, pretty_version)
+        super(name, version, pretty_version)
+
+        @minimum_stability = 'stable'
+        @stability_flags = []
+        @references = []
+        @aliases = []
+      end
+
+    end
+  end
+end

data/lib/composer/package/root_package.rb

@@ -0,0 +1,37 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\RootPackage.php
+#
+# (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.
+#
+
+module Composer
+  module Package
+
+    # The root package represents the project's composer.json
+    # and contains additional metadata
+    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
+      def initialize(name, version, pretty_version)
+        super(name, version, pretty_version)
+
+        @minimum_stability = 'stable'
+        @stability_flags = []
+        @references = []
+        @aliases = []
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,583 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\Version\VersionParser.php
+#
+# (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.
+#
+
+module Composer
+  module Package
+    module Version
+      # Version Parser
+      #
+      # PHP Authors:
+      # Jordi Boggiano <j.boggiano@seld.be>
+      #
+      # 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
+
+        # Parses a name/version pairs and returns an array of pairs + the
+        #
+        # Params:
+        # +pairs+:: array a set of package/version pairs separated by ":", "=" or " "
+        #
+        # Returns:
+        # array[] array of arrays containing a name and (if provided) a version
+        def parse_name_version_pairs(pairs)
+          pairs = pairs.values
+          result = []
+
+          for i in 0..(pairs.length - 1)
+            pair = pairs[i].strip!.gsub(/^([^=: ]+)[=: ](.*)$/, '$1 $2')
+            if nil === pair.index(' ') && pairs.key?(i + 1) && nil === pairs[i + 1].index('/')
+              pair = "#{pair} #{pairs[i + 1]}"
+              i = i + 1
+            end
+
+            if pair.index(' ')
+              name, version = pair.split(' ', 2)
+              result << { 'name' => name, 'version' => version }
+            else
+              result << { 'name' => pair }
+            end
+
+          end
+
+          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
+end