php-composer 0.4.5 → 1.0.0.pre.alpha11

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

@@ -1,6 +1,8 @@
 #
 # This file was ported to ruby from Composer php source code.
+#
 # Original Source: Composer\Package\Loader\ArrayLoader.php
+# Ref SHA: a1427d7fd626d4308c190a267dd7a993f87c6a2a
 #
 # (c) Nils Adermann <naderman@naderman.de>
 #     Jordi Boggiano <j.boggiano@seld.be>
@@ -9,9 +11,13 @@
 # file that was distributed with this source code.
 #
 
+require 'composer/semver'
+
 module Composer
   module Package
     module Loader
+
+      ##
       # Loads a package from a hash
       #
       # PHP Authors:
@@ -20,14 +26,41 @@ module Composer
       #
       # Ruby Authors:
       # Ioannis Kappas <ikappas@devworks.gr>
+      ##
       class HashLoader
+
+        class << self
+
+          def attr_loaders
+            @attr_loaders ||= []
+          end
+
+          def attr_loader( attr, options = {}, &block)
+            if block_given?
+              attr_loaders.push({ attr: attr, options: options, callback: block })
+            else
+              attr_loaders.push({ attr: attr, options: options })
+            end
+          end
+
+        end
+
         def initialize(parser = nil, load_options = false)
-          parser = Composer::Package::Version::VersionParser.new unless parser
+          parser ||= ::Composer::Semver::VersionParser.new
+
+          unless parser.kind_of? (::Composer::Semver::VersionParser)
+            raise ArgumentError,
+                  'Invalid parser supplied.'
+          end
+
           @version_parser = parser
           @load_options = load_options
+
         end
 
         def load(config, class_name = 'Composer::Package::CompletePackage')
+
+          # verify supplied arguments
           unless config
             raise ArgumentError,
                   'Invalid package configuration supplied.'
@@ -50,210 +83,47 @@ module Composer
             version = @version_parser.normalize(config['version'])
           end
 
+          # create the package based on the class specified
           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)
+          # load class specific attributes
+          HashLoader.attr_loaders.each do |loader|
+            package_attr = "#{loader[:attr]}="
+            if package.respond_to? package_attr
+              if loader[:callback]
+                instance_exec config, package, &loader[:callback]
+              else
+                if loader[:options][:from]
+                  config_key = loader[:options][:from]
+                else
+                  config_key = loader[:attr].to_s.tr('_', '-')
+                end
+
+                if config.key? config_key
+                  config_value = config[config_key]
+                  unless config_value.nil? || config_value.empty?
+                    package.send package_attr, config_value
+                  end
+                end
               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')
-              )
+          if (alias_normalized = get_branch_alias(config))
+            if package.instance_of? ::Composer::Package::RootPackage
+              alias_class = 'RootAliasPackage'
             else
-              package = Composer::Package::AliasPackage.new(
-                package,
-                alias_normalized,
-                alias_normalized.gsub(/(\.9{7})+/, '.x')
-              )
+              alias_class = 'AliasPackage'
             end
+            package = Object.const_get("::Composer::Package::#{alias_class}").new(
+              package,
+              alias_normalized,
+              alias_normalized.gsub(/(\.9{7})+/, '.x')
+            )
           end
 
           if @load_options && config.key?('transport-options')
@@ -263,52 +133,46 @@ module Composer
           package
         end
 
-        # Retrieves a branch alias
-        # (dev-master => 1.0.x-dev for example) if it exists
+        ##
+        # Retrieves a branch alias if it exists.
         #
-        # Params:
-        # +config+ array The entire package config
+        # i.e.(dev-master => 1.0.x-dev)
         #
-        # Returns:
-        # string|nil normalized version of the branch alias
-        # or null if there is none
+        # @param config array
+        #   The entire package config
+        #
+        # @return string|nil
+        # The normalized version of the branch alias or nil 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')
+          if config.key?('version') && (config['version'].start_with?('dev-') || config['version'].end_with?('-dev'))
+            if 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 unless 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')
+                # 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 unless validated_target_branch.end_with?('-dev')
 
-            # ensure that it is the current branch aliasing itself
-            next if config['version'].downcase != source_branch.downcase
+                # 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)
+                # 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
+                return validated_target_branch
+              end
+            end
           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
+        require_relative 'hash_loader/package_attribute_loaders'
+        require_relative 'hash_loader/complete_package_attribute_loaders'
+        require_relative 'hash_loader/root_package_attribute_loaders'
 
       end
     end

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

@@ -0,0 +1,83 @@
+#
+# This file was ported to ruby from Composer php source code.
+#
+# Original Source: Composer\Package\Loader\ArrayLoader.php
+# Ref SHA: a1427d7fd626d4308c190a267dd7a993f87c6a2a
+#
+# (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
+      class HashLoader
+
+        attr_loader :scripts do |config, package|
+          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
+        end
+
+        attr_loader :description do |config, package|
+          if config.key?('description') && config['description'].is_a?(String)
+            unless config['description'].empty?
+              package.description = config['description']
+            end
+          end
+        end
+
+        attr_loader :homepage do |config, package|
+          if config.key?('homepage') && config['homepage'].is_a?(String)
+            unless config['homepage'].empty?
+              package.homepage = config['homepage']
+            end
+          end
+        end
+
+        attr_loader :keywords do |config, package|
+          if config.key?('keywords') && config['keywords'].is_a?(Array)
+            unless config['keywords'].empty?
+              package.keywords = config['keywords']
+            end
+          end
+        end
+
+        attr_loader :license do |config, package|
+          if config.key?('license')
+            unless config['license'].empty?
+              package.license = config['license'].is_a?(Array) ? config['license'] : [config['license']]
+            end
+          end
+        end
+
+        attr_loader :authors do |config, package|
+          if config.key?('authors') && config['authors'].is_a?(Array)
+            unless config['authors'].empty?
+              package.authors = config['authors']
+            end
+          end
+        end
+
+        attr_loader :support do |config, package|
+          if config.key?('support')
+            package.support = config['support']
+          end
+        end
+
+        attr_loader :abandoned do |config, package|
+          if config.key?('abandoned')
+            package.abandoned = config['abandoned']
+          end
+        end
+
+      end
+    end
+  end
+end