php-composer 0.1.0

data/lib/composer/package/link_constraint/version_constraint.rb

@@ -0,0 +1,221 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\LinkConstraint\VersionConstraint.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 LinkConstraint
+      class VersionConstraint < SpecificConstraint
+        attr_reader :operator, :version
+
+        @@cache = nil
+
+        # Sets operator and version to compare a package with
+        # @param string $operator A comparison operator
+        # @param string $version  A version to compare to
+        def initialize(operator, version)
+            if operator === '='
+              operator = '=='
+            end
+
+            if operator === '<>'
+              operator = '!='
+            end
+
+            @operator = operator
+            @version = version
+        end
+
+        def version_compare(a, b, operator, compare_branches = false)
+
+          a_is_branch = 'dev-' === a[0...4]
+          b_is_branch = 'dev-' === b[0...4]
+          if a_is_branch && b_is_branch
+            return operator == '==' && a === b
+          end
+
+          # when branches are not comparable, we make sure dev branches never match anything
+          if !compare_branches && (a_is_branch || b_is_branch)
+            return false
+          end
+
+          # Standardise versions
+          ver_a = a.strip.gsub(/([\-?\_?\+?])/, '.').gsub(/([^0-9\.]+)/, '.$1.').gsub(/\.\./, '.').split('.')
+          ver_b = b.strip.gsub(/([\-?\_?\+?])/, '.').gsub(/([^0-9\.]+)/, '.$1.').gsub(/\.\./, '.').split('.')
+
+          # Replace empty entries at the start of the array
+          while ver_a[0] && ver_a[0].empty?
+            ver_a.shift
+          end
+          while ver_b[0] && ver_b[0].empty?
+            ver_b.shift
+          end
+
+          # Release state order
+          # '#' stands for any number
+          versions = {
+            'dev'   => 0,
+            'alpha' => 1,
+            'a'     => 1,
+            'beta'  => 2,
+            'b'     => 2,
+            'RC'    => 3,
+            '#'     => 4,
+            'p'     => 5,
+            'pl'    => 5
+          }
+
+          # Loop through each segment in the version string
+          compare = 0
+          for i in 0..([ver_a.length, ver_b.length].min - 1)
+          # for (i = 0, $x = [ver_a.length, ver_b.length].min; i < $x; i++) {
+
+            next if ver_a[i] == ver_b[i]
+
+            i1 = ver_a[i]
+            i2 = ver_b[i]
+
+            i1_is_numeric = true if Float(i1) rescue false
+            i2_is_numeric = true if Float(i2) rescue false
+
+            if i1_is_numeric && i2_is_numeric
+              compare = (i1 < i2) ? -1 : 1
+              break
+            end
+
+            # We use the position of '#' in the versions list
+            # for numbers... (so take care of # in original string)
+            if i1 == '#'
+                i1 = ''
+            elsif i1_is_numeric
+              i1 = '#';
+            end
+
+            if i2 == '#'
+              i2 = ''
+            elsif i2_is_numeric
+              i2 = '#'
+            end
+
+            if !versions[i1].nil? && versions[i2].nil?
+              compare = versions[i1] < versions[i2] ? -1 : 1
+            elsif !versions[i1].nil?
+              compare = 1;
+            elsif !versions[i2].nil?
+              compare = -1;
+            else
+              compare = 0;
+            end
+
+            break;
+
+          end
+
+          # If previous loop didn't find anything, compare the "extra" segments
+          if compare == 0
+            if ver_b.length > ver_a.length
+              if !ver_b[i].nil && !versions[ver_b[i]].nil
+                compare = (versions[ver_b[i]] < 4) ? 1 : -1;
+              else
+                compare = -1;
+              end
+            elsif ver_b.length < ver_a.length
+              if !ver_a[i].nil && !versions[ver_a[i]].nil
+                compare = (versions[ver_a[i]] < 4) ? -1 : 1;
+              else
+                compare = 1;
+              end
+            end
+          end
+
+          # Compare the versions
+          case operator
+          when '>', 'gt'
+            return compare > 0
+          when '>=', 'ge'
+            return compare >= 0
+          when '<=', 'le'
+            return compare <= 0
+          when '==', '=', 'eq'
+            return compare == 0
+          when '<>', '!=', 'ne'
+            return compare != 0
+          when '', '<', 'lt'
+            return compare < 0
+          end
+
+          false
+        end
+
+        # @param  VersionConstraint provider
+        # @param  bool              compare_branches
+        # @return bool
+        def match_specific(provider, compare_branches = false)
+          @@cache = {} unless @@cache
+          @@cache[@operator] = {} unless @@cache.key?(@operator)
+          @@cache[@operator][@version] = {} unless @@cache[@operator].key?(@version)
+          @@cache[@operator][@version][provider.operator] = {} unless @@cache[@operator][@version].key?(provider.operator)
+          @@cache[@operator][@version][provider.operator][provider.version] = {} unless @@cache[@operator][@version][provider.operator].key?(provider.version)
+
+          if @@cache[@operator][@version][provider.operator][provider.version].key?(compare_branches)
+            return @@cache[@operator][@version][provider.operator][provider.version][compare_branches]
+          end
+
+          (@@cache[@operator][@version][provider.operator][provider.version][compare_branches] = do_match_specific(provider, compare_branches))
+        end
+
+        def to_s
+          "#{@operator} #{@version}"
+        end
+
+        private
+
+        # /**
+        #  * @param  VersionConstraint provider
+        #  * @param  bool              compare_branches
+        #  * @return bool
+        def do_match_specific(provider, compare_branches = false)
+          self_op_ne = @operator.gsub('=', '')
+          provider_op_ne = provider.operator.gsub('=', '')
+
+          self_op_is_eq = '==' === @operator
+          self_op_is_ne = '!=' === @operator
+          provider_op_is_eq = '==' === provider.operator
+          provider_op_is_ne = '!=' === provider.operator
+
+          # '!=' operator is match when other operator is not '==' operator or version is not match
+          # these kinds of comparisons always have a solution
+          if self_op_is_ne || provider_op_is_ne
+            return !self_op_is_eq && !provider_op_is_eq ||
+                version_compare(provider.version, @version, '!=', compare_branches)
+          end
+
+          # an example for the condition is <= 2.0 & < 1.0
+          # these kinds of comparisons always have a solution
+          if @operator != '==' && self_op_ne == provider_op_ne
+            return true
+          end
+
+          if version_compare(provider.version, @version, @operator, compare_branches)
+            # special case, e.g. require >= 1.0 and provide < 1.0
+            # 1.0 >= 1.0 but 1.0 is outside of the provided interval
+            if provider.version == @version && provider.operator == provider_op_ne && @operator != self_op_ne
+              return false
+            end
+
+            return true
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+#
+# This file was ported to ruby from Composer php source code.
+# Original Source: Composer\Package\Loader\ArrayLoader.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 hash
+      #
+      # PHP Authors:
+      # Konstantin Kudryashiv <ever.zet@gmail.com>
+      # Jordi Boggiano <j.boggiano@seld.be>
+      #
+      # Ruby Authors:
+      # Ioannis Kappas <ikappas@devworks.gr>
+      class HashLoader
+        def initialize(parser = nil, load_options = false)
+          parser = Composer::Package::Version::VersionParser.new unless parser
+          @version_parser = parser
+          @load_options = load_options
+        end
+
+        def load(config, class_name = 'Composer::Package::CompletePackage')
+          unless config
+            raise ArgumentError,
+                  'Invalid package configuration supplied.'
+          end
+
+          unless config.key?('name')
+            raise UnexpectedValueError,
+                  "Unknown package has no name defined (#{config.to_json})."
+          end
+
+          unless config.key?('version')
+            raise UnexpectedValueError,
+                  "Package #{config['name']} has no version defined."
+          end
+
+          # handle already normalized versions
+          if config.key?('version_normalized')
+            version = config['version_normalized']
+          else
+            version = @version_parser.normalize(config['version'])
+          end
+
+          package = Object.const_get(class_name).new(
+            config['name'],
+            version,
+            config['version']
+          )
+
+          # parse type
+          if config.key?('type')
+            package.type = config['type'].downcase
+          else
+            package.type = 'library'
+          end
+
+          # parse target-dir
+          if config.key?('target-dir')
+            package.target_dir = config['target-dir']
+          end
+
+          # parse extra
+          if config.key?('extra') && config['extra'].is_a?(Hash)
+            package.extra = config['extra']
+          end
+
+          # parse bin
+          if config.key?('bin')
+            unless config['bin'].is_a?(Array)
+              raise UnexpectedValueError,
+                    "Package #{config['name']}'s bin key should be an hash, \
+                    #{config['bin'].class.name} given."
+            end
+            config['bin'].each do |bin|
+              bin.gsub!(/^\/+/, '')
+            end
+            package.binaries = config['bin']
+          end
+
+          # parse installation source
+          if config.key?('installation-source')
+            package.installation_source = config['installation-source']
+          end
+
+          # parse source
+          if config.key?('source')
+            if [:type, :url, :reference].all? {|k| config['source'].key? k}
+              raise UnexpectedValueError,
+                    "Package #{config['name']}'s source key should be \
+                    specified as \
+                    {\"type\": ..., \"url\": ..., \"reference\": ...}, \n
+                    #{config['source'].to_json} given."
+            end
+            package.source_type = config['source']['type']
+            package.source_url = config['source']['url']
+            package.source_reference = config['source']['reference']
+            if config['source'].key?('mirrors')
+              package.source_mirrors = config['source']['mirrors']
+            end
+          end
+
+          #parse dist
+          if config.key?('dist')
+            if [:type, :url].all? {|k| config['dist'].key? k}
+              raise UnexpectedValueError,
+                    "Package #{config['name']}'s dist key should be \
+                    specified as \
+                    {\"type\": ..., \"url\": ..., \"reference\": ..., \"shasum\": ...},\n
+                    #{config['dist'].to_json} given."
+            end
+            package.dist_type = config['dist']['type']
+            package.dist_url = config['dist']['url']
+
+            package.dist_reference = config['dist'].key?('reference') ?
+                                      config['dist']['reference'] : nil
+
+            package.dist_sha1_checksum = config['dist'].key?('shasum') ?
+                                      config['dist']['shasum'] : nil
+
+            if config['dist'].key?('mirrors')
+              package.dist_mirrors = config['dist']['mirrors']
+            end
+          end
+
+          # parse supported link types
+          Composer::Package::BasePackage::SUPPORTED_LINK_TYPES.each do |type, opts|
+            next if !config.key?(type)
+            package.send(
+              "#{opts['method']}=",
+              @version_parser.parse_links(
+                package.name,
+                package.pretty_version,
+                opts['description'],
+                config[type]
+              )
+            )
+          end
+
+          # parse suggest
+          if config.key?('suggest') && config['suggest'].is_a?(Hash)
+            config['suggest'].each do |target, reason|
+              if 'self.version' === reason.strip!
+                config['suggest'][target] = package.pretty_version
+              end
+            end
+            package.suggests = config['suggest']
+          end
+
+          # parse autoload
+          if config.key? 'autoload'
+            package.autoload = config['autoload']
+          end
+
+          # parse autoload-dev
+          if config.key? 'autoload-dev'
+            package.dev_autoload = config['autoload-dev']
+          end
+
+          # parse include-path
+          if config.key? 'include-path'
+            package.include_paths = config['include-path']
+          end
+
+          # parse time
+          if !is_empty?(config, 'time')
+            time = is_numeric?(config['time']) ? "@#{config['time']}" : config['time']
+            begin
+              date = Time.zone.parse(time)
+              package.release_date = date
+            rescue Exception => e
+              log("Time Exception #{e}")
+            end
+          end
+
+          # parse notification url
+          if !is_empty?(config, 'notification-url')
+            package.notification_url = config['notification-url']
+          end
+
+          # parse archive excludes
+          if config.key?('archive') &&
+             config['archive'].key?('exclude') &&
+             !config['archive']['exclude'].empty?
+            package.archive_excludes = config['archive']['exclude']
+          end
+
+          if package.instance_of?(Composer::Package::CompletePackage)
+
+            # parse scripts
+            if config.key?('scripts') && config['scripts'].is_a?(Array)
+              config['scripts'].each do |event, listeners|
+                config['scripts'][event] = Array(listeners)
+              end
+              package.scripts = config['scripts']
+            end
+
+            # parse description
+            if !is_empty?(config, 'description') && config['description'].is_a?(String)
+              package.description = config['description']
+            end
+
+            # parse homepage
+            if !is_empty?(config, 'homepage') && config['homepage'].is_a?(String)
+              package.homepage = config['homepage']
+            end
+
+            # parse keywords
+            if !is_empty?(config, 'keywords') && config['keywords'].is_a?(Array)
+              package.keywords = config['keywords']
+            end
+
+            # parse license
+            if !is_empty?(config, 'license')
+              package.license = config['license'].is_a?(Array) ? config['license'] : [config['license']]
+            end
+
+            # parse authors
+            if !is_empty?(config, 'authors') && config['authors'].is_a?(Array)
+              package.authors = config['authors']
+            end
+
+            # parse support
+            if config.key?('support')
+              package.support = config['support']
+            end
+
+            # parse abandoned
+            if config.key?('abandoned')
+              package.abandoned = config['abandoned']
+            end
+
+          end
+
+          if alias_normalized = get_branch_alias(config)
+            if package.instance_of?(Composer::Package::RootPackage)
+              package = Composer::Package::RootAliasPackage.new(
+                package,
+                alias_normalized,
+                alias_normalized.gsub(/(\.9{7})+/, '.x')
+              )
+            else
+              package = Composer::Package::AliasPackage.new(
+                package,
+                alias_normalized,
+                alias_normalized.gsub(/(\.9{7})+/, '.x')
+              )
+            end
+          end
+
+          if @load_options && config.key?('transport-options')
+            package.transport_options = config['transport-options']
+          end
+
+          package
+        end
+
+        # Retrieves a branch alias
+        # (dev-master => 1.0.x-dev for example) if it exists
+        #
+        # Params:
+        # +config+ array The entire package config
+        #
+        # Returns:
+        # string|nil normalized version of the branch alias
+        # or null if there is none
+        def get_branch_alias(config)
+          return nil unless
+            (config['version'].start_with?('dev-') || config['version'].end_with?('-dev')) &&
+            config.key?('extra') &&
+            config['extra'].key?('branch-alias') &&
+            config['extra']['branch-alias'].is_a?(Hash)
+
+          config['extra']['branch-alias'].each do |source_branch, target_branch|
+            # ensure it is an alias to a -dev package
+            next if !target_branch.end_with?('-dev')
+
+            # normalize without -dev and ensure it's a numeric branch that is parseable
+            validated_target_branch = @version_parser.normalize_branch(target_branch[0..-5])
+            next if !validated_target_branch.end_with?('-dev')
+
+            # ensure that it is the current branch aliasing itself
+            next if config['version'].downcase != source_branch.downcase
+
+            # If using numeric aliases ensure the alias is a valid subversion
+            source_prefix = @version_parser.parse_numeric_alias_prefix(source_branch)
+            target_prefix = @version_parser.parse_numeric_alias_prefix(target_branch)
+            next if source_prefix && target_prefix && target_prefix.index(source_prefix) != 0 #(stripos($targetPrefix, $sourcePrefix) !== 0)
+
+            return validated_target_branch
+          end
+          nil
+        end
+
+        private
+
+        def is_numeric?(value)
+          true if Float(value) rescue false
+        end
+
+        def is_empty?(config, key)
+          config.key?(key) ? config[key].empty? : true
+        end
+
+      end
+    end
+  end
+end