fareh · September 15, 2015 22:25
diff --git a/Santander_.gitignore b/Santander_.gitignore
 # Created by https://www.gitignore.io

 ### PhpStorm ###
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm

 *.iml

 ## Directory-based project format:
 .idea/

 ## File-based project format:
 *.ipr
 *.iws

 ## Plugin-specific files:

 # mpeltonen/sbt-idea plugin
 .idea_modules/


 ### Symfony ###
 # Cache and logs (Symfony2)
 /app/cache/*
 /app/logs/*
 !app/cache/.gitkeep
 !app/logs/.gitkeep

 # Phing artifacts builded.
 /app/build/

 # Parameters
 /app/config/parameters.yml

 # Managed by Composer
 /app/bootstrap.php.cache
 /bin/*
 !bin/console
 !bin/symfony_requirements
 /vendor/

 # Assets and user uploads
 /web/bundles/
 /web/uploads/

 # PHPUnit
 /app/phpunit.xml
 /phpunit.xml

 # Build data
 /build/

 # Composer PHAR
 /composer.phar

 # Media
 /web/media

 .DS_Store
 *.php~
 /web/front/bower_components/*
 /web/front/node_modules/*

 # for translation system
 /app/Resources/translations
diff --git a/Santander_.idea_.name b/Santander_.idea_.name
 Santander
diff --git a/Santander_.idea_encodings.xml b/Santander_.idea_encodings.xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
 </project>

diff --git a/Santander_.idea_misc.xml b/Santander_.idea_misc.xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectRootManager" version="2" />
 </project>

diff --git a/Santander_.idea_modules.xml b/Santander_.idea_modules.xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/Santander.iml" filepath="$PROJECT_DIR$/.idea/Santander.iml" />
    </modules>
  </component>
 </project>

diff --git a/Santander_.idea_Santander.iml b/Santander_.idea_Santander.iml
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="WEB_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$" />
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
    <orderEntry type="module-library">
      <library name="PHARS">
        <CLASSES>
          <root url="phar://$MODULE_DIR$/composer.phar" />
        </CLASSES>
        <SOURCES>
          <root url="phar://$MODULE_DIR$/composer.phar" />
        </SOURCES>
      </library>
    </orderEntry>
  </component>
 </module>

diff --git a/Santander_.idea_scopes_scope_settings.xml b/Santander_.idea_scopes_scope_settings.xml
 <component name="DependencyValidationManager">
  <state>
    <option name="SKIP_IMPORT_STATEMENTS" value="false" />
  </state>
 </component>
diff --git a/Santander_.idea_vcs.xml b/Santander_.idea_vcs.xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="" vcs="" />
  </component>
 </project>

diff --git a/Santander_app_.htaccess b/Santander_app_.htaccess
 <IfModule mod_authz_core.c>
    Require all denied
 </IfModule>
 <IfModule !mod_authz_core.c>
    Order deny,allow
    Deny from all
 </IfModule>
diff --git a/Santander_app_AppCache.php b/Santander_app_AppCache.php
 <?php

 require_once __DIR__.'/AppKernel.php';

 use Symfony\Bundle\FrameworkBundle\HttpCache\HttpCache;

 class AppCache extends HttpCache
 {
 }
diff --git a/Santander_app_AppKernel.php b/Santander_app_AppKernel.php
 <?php

 use Symfony\Component\HttpKernel\Kernel;
 use Symfony\Component\Config\Loader\LoaderInterface;

 class AppKernel extends Kernel
 {
    public function registerBundles()
    {
        $bundles = array(
            new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
            new Symfony\Bundle\SecurityBundle\SecurityBundle(),
            new Symfony\Bundle\TwigBundle\TwigBundle(),
            new Symfony\Bundle\MonologBundle\MonologBundle(),
            new Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),
            new Symfony\Bundle\AsseticBundle\AsseticBundle(),
            new Doctrine\Bundle\DoctrineBundle\DoctrineBundle(),
            new Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle(),

            new JMS\AopBundle\JMSAopBundle(),
            new JMS\SecurityExtraBundle\JMSSecurityExtraBundle(),
            new JMS\DiExtraBundle\JMSDiExtraBundle($this),
            new JMS\SerializerBundle\JMSSerializerBundle(),
            new FOS\UserBundle\FOSUserBundle(),
            new Lexik\Bundle\FormFilterBundle\LexikFormFilterBundle(),
            new Liip\ImagineBundle\LiipImagineBundle(),
            new JMS\I18nRoutingBundle\JMSI18nRoutingBundle(),
            new JMS\TranslationBundle\JMSTranslationBundle(),
            new Knp\Bundle\PaginatorBundle\KnpPaginatorBundle(),
            new A2lix\TranslationFormBundle\A2lixTranslationFormBundle(),
            new Genemu\Bundle\FormBundle\GenemuFormBundle(),
            new Accord\MandrillSwiftMailerBundle\AccordMandrillSwiftMailerBundle(),
            new Liuggio\ExcelBundle\LiuggioExcelBundle(),

            new Eesa\CoreBundle\EesaCoreBundle(),
            new Eesa\UserBundle\EesaUserBundle(),
            new Eesa\MediaBundle\EesaMediaBundle(),
            new Eesa\GeoBundle\EesaGeoBundle(),
            new Eesa\WebinarBundle\EesaWebinarBundle(),
            new Eesa\SantanderBundle\EesaSantanderBundle(),
            new Eesa\SanAdminBundle\EesaSanAdminBundle(),
            new Eesa\BridgeBundle\EesaBridgeBundle(),
            new Eesa\I18nRoutingBundle\EesaI18nRoutingBundle(),
            new Eesa\DataBundle\EesaDataBundle(),
        );

        if (in_array($this->getEnvironment(), array('dev', 'test'))) {
            $bundles[] = new Symfony\Bundle\DebugBundle\DebugBundle();
            $bundles[] = new Symfony\Bundle\WebProfilerBundle\WebProfilerBundle();
            $bundles[] = new Sensio\Bundle\DistributionBundle\SensioDistributionBundle();
            $bundles[] = new Sensio\Bundle\GeneratorBundle\SensioGeneratorBundle();
        }

        if (in_array($this->getEnvironment(), array('prod'))) {
            $bundles[] = new Evolution7\BugsnagBundle\BugsnagBundle();
        }

        return $bundles;
    }

    public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $loader->load($this->getRootDir().'/config/config_'.$this->getEnvironment().'.yml');

        $envParamaters = $this->getEnvParameters();
        if (empty($envParamaters['fulldomain'])) {
            $loader->load($this->getRootDir().'/config/i18n.yml');
        }
    }
 }
diff --git a/Santander_app_autoload.php b/Santander_app_autoload.php
 <?php

 use Doctrine\Common\Annotations\AnnotationRegistry;
 use Composer\Autoload\ClassLoader;

 /**
 * @var ClassLoader $loader
 */
 $loader = require __DIR__.'/../vendor/autoload.php';

 AnnotationRegistry::registerLoader(array($loader, 'loadClass'));

 return $loader;
diff --git a/Santander_app_check.php b/Santander_app_check.php
 <?php

 require_once dirname(__FILE__).'/SymfonyRequirements.php';

 $lineSize = 70;
 $symfonyRequirements = new SymfonyRequirements();
 $iniPath = $symfonyRequirements->getPhpIniConfigPath();

 echo_title('Symfony2 Requirements Checker');

 echo '> PHP is using the following php.ini file:'.PHP_EOL;
 if ($iniPath) {
    echo_style('green', '  '.$iniPath);
 } else {
    echo_style('warning', '  WARNING: No configuration file (php.ini) used by PHP!');
 }

 echo PHP_EOL.PHP_EOL;

 echo '> Checking Symfony requirements:'.PHP_EOL.'  ';

 $messages = array();
 foreach ($symfonyRequirements->getRequirements() as $req) {
    /** @var $req Requirement */
    if ($helpText = get_error_message($req, $lineSize)) {
        echo_style('red', 'E');
        $messages['error'][] = $helpText;
    } else {
        echo_style('green', '.');
    }
 }

 $checkPassed = empty($messages['error']);

 foreach ($symfonyRequirements->getRecommendations() as $req) {
    if ($helpText = get_error_message($req, $lineSize)) {
        echo_style('yellow', 'W');
        $messages['warning'][] = $helpText;
    } else {
        echo_style('green', '.');
    }
 }

 if ($checkPassed) {
    echo_block('success', 'OK', 'Your system is ready to run Symfony2 projects', true);
 } else {
    echo_block('error', 'ERROR', 'Your system is not ready to run Symfony2 projects', true);

    echo_title('Fix the following mandatory requirements', 'red');

    foreach ($messages['error'] as $helpText) {
        echo ' * '.$helpText.PHP_EOL;
    }
 }

 if (!empty($messages['warning'])) {
    echo_title('Optional recommendations to improve your setup', 'yellow');

    foreach ($messages['warning'] as $helpText) {
        echo ' * '.$helpText.PHP_EOL;
    }
 }

 echo PHP_EOL;
 echo_style('title', 'Note');
 echo '  The command console could use a different php.ini file'.PHP_EOL;
 echo_style('title', '~~~~');
 echo '  than the one used with your web server. To be on the'.PHP_EOL;
 echo '      safe side, please check the requirements from your web'.PHP_EOL;
 echo '      server using the ';
 echo_style('yellow', 'web/config.php');
 echo ' script.'.PHP_EOL;
 echo PHP_EOL;

 exit($checkPassed ? 0 : 1);

 function get_error_message(Requirement $requirement, $lineSize)
 {
    if ($requirement->isFulfilled()) {
        return;
    }

    $errorMessage  = wordwrap($requirement->getTestMessage(), $lineSize - 3, PHP_EOL.'   ').PHP_EOL;
    $errorMessage .= '   > '.wordwrap($requirement->getHelpText(), $lineSize - 5, PHP_EOL.'   > ').PHP_EOL;

    return $errorMessage;
 }

 function echo_title($title, $style = null)
 {
    $style = $style ?: 'title';

    echo PHP_EOL;
    echo_style($style, $title.PHP_EOL);
    echo_style($style, str_repeat('~', strlen($title)).PHP_EOL);
    echo PHP_EOL;
 }

 function echo_style($style, $message)
 {
    // ANSI color codes
    $styles = array(
        'reset' => "\033[0m",
        'red' => "\033[31m",
        'green' => "\033[32m",
        'yellow' => "\033[33m",
        'error' => "\033[37;41m",
        'success' => "\033[37;42m",
        'title' => "\033[34m",
    );
    $supports = has_color_support();

    echo($supports ? $styles[$style] : '').$message.($supports ? $styles['reset'] : '');
 }

 function echo_block($style, $title, $message)
 {
    $message = ' '.trim($message).' ';
    $width = strlen($message);

    echo PHP_EOL.PHP_EOL;

    echo_style($style, str_repeat(' ', $width).PHP_EOL);
    echo_style($style, str_pad(' ['.$title.']',  $width, ' ', STR_PAD_RIGHT).PHP_EOL);
    echo_style($style, str_pad($message,  $width, ' ', STR_PAD_RIGHT).PHP_EOL);
    echo_style($style, str_repeat(' ', $width).PHP_EOL);
 }

 function has_color_support()
 {
    static $support;

    if (null === $support) {
        if (DIRECTORY_SEPARATOR == '\\') {
            $support = false !== getenv('ANSICON') || 'ON' === getenv('ConEmuANSI');
        } else {
            $support = function_exists('posix_isatty') && @posix_isatty(STDOUT);
        }
    }

    return $support;
 }
diff --git a/Santander_app_config_config.yml b/Santander_app_config_config.yml
 imports:
    - { resource: parameters.yml }
    - { resource: security.yml }
    - { resource: services.yml }
    - { resource: doctrine.yml }
    - { resource: ../../vendor/knplabs/doctrine-behaviors/config/orm-services.yml }
    - { resource: serializer.yml }

 framework:
    #esi:             ~
    translator:      { fallbacks: ["%locale%"] }
    secret:          "%secret%"
    router:
        resource: "%kernel.root_dir%/config/routing.yml"
        strict_requirements: ~
    form:            ~
    csrf_protection: ~
    validation:      { enable_annotations: true }
    templating:
        engines: ['twig']
        #assets_version: SomeVersionScheme
        assets_base_urls:
            http:
                - "http://%domain%"
            ssl:
                - "https://%domain%"
    default_locale:  "%locale%"
    trusted_hosts:   ~
    trusted_proxies: ~
    fragments:       ~
    http_method_override: true

 # Twig Configuration
 twig:
    debug:            "%kernel.debug%"
    strict_variables: "%kernel.debug%"
    globals:
        contextManager: "@eesa_santander.context_manager"
        fusion_frontoffice_baseurl: %fusion_frontoffice_baseurl%
        documentDomain: %documentDomain%
    form:
        resources:
            - LexikFormFilterBundle:Form:form_div_layout.html.twig

 # Assetic Configuration
 assetic:
    debug:          "%kernel.debug%"
    use_controller: false
    bundles:        [ ]
    filters:
        cssrewrite: ~

 # Swiftmailer Configuration
 swiftmailer:
    transport: %mailer_transport%
    host:      "%mailer_host%"
    username:  "%mailer_user%"
    password:  "%mailer_password%"
    spool:     { type: memory }

 accord_mandrill_swift_mailer:
    api_key: %mandrill_api_key%

 eesa_core:
    mandrill_api_key: %mandrill_api_key%

 # FOS User
 fos_user:
    db_driver: orm
    firewall_name: main
    user_class: Eesa\SantanderBundle\Entity\User


 # JMSI18nRoutingBundle Configuration
 eesa_i18n_routing:
    hosts:
        en: [en.%domain%, en.%webinarDomain%]
        pl: [pl.%domain%, pl.%webinarDomain%]
        es: [es.%domain%, es.%webinarDomain%]
        pt: [pt.%domain%, pt.%webinarDomain%]

 jms_i18n_routing:
    default_locale: en
    locales: [en, pl, es, pt]
    strategy: custom
    hosts:
        en: en.%fulldomain%
        pl: pl.%fulldomain%
        es: es.%fulldomain%
        pt: pt.%fulldomain%
    redirect_to_host: true

 # KNP Paginator
 knp_paginator:
    page_range: 5                      # default page range used in pagination control
    default_options:
        page_name: page                # page query parameter name
        sort_field_name: sort          # sort field query parameter name
        sort_direction_name: direction # sort direction query parameter name
        distinct: true                 # ensure distinct results, useful when ORM queries are using GROUP BY statements
    template:
        pagination: KnpPaginatorBundle:Pagination:twitter_bootstrap_v3_pagination.html.twig     # sliding pagination controls template
        sortable: KnpPaginatorBundle:Pagination:sortable_link.html.twig # sort link template

 a2lix_translation_form:
    locale_provider: default
    locales: [es, en, pt, pl]
    manager_registry: doctrine
    templating: "A2lixTranslationFormBundle::default.html.twig"

 genemu_form:
    captcha:
        enabled: true
        width:            100
        height:           46
        length:           4
        format:           'png'
        chars:            '0123456789'
        font_size:        16
        font_color:       ['ff0016', '8B8787', '550707', '3526E6', '88531E']
        font_dir:         %kernel.root_dir%/../web/bundles/genemuform/fonts
        fonts:            ['whoobub.ttf']
        background_color: 'DDDDDD'
        border_color:     '808080'
        grayscale:        false

 # LiipImagineBundle Configuration
 liip_imagine:
    resolvers:
       default:
          web_path: ~

    filter_sets:
        cache: ~
        bo_thumbnail:
            quality: 75
            filters:
                thumbnail: { size: [75, 75], mode: outbound, allow_upscale: true }
        speaker_thumbnail:
            quality: 75
            filters:
                thumbnail: { size: [187, 186], mode: outbound, allow_upscale: true }
        webinar_thumbnail:
            quality: 75
            filters:
                thumbnail: { size: [113, 97], mode: outbound, allow_upscale: true }
        webinar_small:
            quality: 75
            filters:
                thumbnail: { size: [300, 255], mode: outbound, allow_upscale: true }
        webinar_big:
            quality: 75
            filters:
                thumbnail: { size: [400, 280], mode: outbound, allow_upscale: true }
diff --git a/Santander_app_config_config_dev.yml b/Santander_app_config_config_dev.yml
 imports:
    - { resource: config.yml }

 framework:
    router:
        resource: "%kernel.root_dir%/config/routing_dev.yml"
        strict_requirements: true
    profiler: { only_exceptions: false }
    session:
        #handler_id:  ~
        save_path: /tmp/santander
        cookie_domain: %cookieDomain%
        name: SFSESSID

 web_profiler:
    toolbar: true
    intercept_redirects: false

 monolog:
    handlers:
        main:
            type:   stream
            path:   "%kernel.logs_dir%/%kernel.environment%.log"
            level:  debug
        console:
            type:   console
            bubble: false
            verbosity_levels:
                VERBOSITY_VERBOSE: INFO
                VERBOSITY_VERY_VERBOSE: DEBUG
            channels: ["!doctrine"]
        console_very_verbose:
            type:   console
            bubble: false
            verbosity_levels:
                VERBOSITY_VERBOSE: NOTICE
                VERBOSITY_VERY_VERBOSE: NOTICE
                VERBOSITY_DEBUG: DEBUG
            channels: ["doctrine"]
        # uncomment to get logging in your browser
        # you may have to allow bigger header sizes in your Web server configuration
        #firephp:
        #    type:   firephp
        #    level:  info
        #chromephp:
        #    type:   chromephp
        #    level:  info

 assetic:
    use_controller: true

 #swiftmailer:
 #    transport: gmail
 #    username:  teamclickeat
 #    password:  uclickueat

 genemu_form:
    captcha:
        code: 1234
diff --git a/Santander_app_config_config_prod.yml b/Santander_app_config_config_prod.yml
 imports:
    - { resource: config.yml }

 framework:
    session:
        #handler_id:  ~
        save_path: /tmp/santander
        cookie_domain: .santandertrade.com
        name: SFSESSID
 #    validation:
 #        cache: apc

 #doctrine:
 #    orm:
 #        metadata_cache_driver: apc
 #        result_cache_driver: apc
 #        query_cache_driver: apc

 monolog:
    handlers:
        main:
            type:         fingers_crossed
            action_level: error
            handler:      nested
        nested:
            type:  stream
            path:  "%kernel.logs_dir%/%kernel.environment%.log"
            level: debug
        console:
            type:  console

 bugsnag:
    api_key: f9ac69c85a5b299d60d5cd32e7e17575
    notify_stages: [ production ]
diff --git a/Santander_app_config_config_test.yml b/Santander_app_config_config_test.yml
 imports:
    - { resource: config_dev.yml }

 framework:
    test: ~
    session:
        storage_id: session.storage.mock_file
    profiler:
        collect: false

 web_profiler:
    toolbar: false
    intercept_redirects: false

 swiftmailer:
    disable_delivery: true
diff --git a/Santander_app_config_deploy.rb b/Santander_app_config_deploy.rb
 # config valid only for current version of Capistrano
 lock '3.4.0'

 set :application, 'santander-hub-webinar' # no whitespace
 set :repo_url, '[email protected]:eesa/Santander.git'

 set :composer_install_flags, '--no-dev --prefer-dist --no-interaction --optimize-autoloader'

 # Files that need to remain the same between deploys
 set :linked_files, [fetch(:app_path) + "/config/parameters.yml"]

 # Dirs that need to remain the same between deploys (shared dirs)
 set :linked_dirs,           [fetch(:log_path), fetch(:web_path) + "/uploads", fetch(:web_path) + "/media", fetch(:app_path) + "/Resources/translations"]

 # Method used to set permissions (:chmod, :acl, or :chgrp)
 set :permission_method,     :acl
 # Execute set permissions
 set :use_set_permissions,   true
 # Dirs that need to be writable by the HTTP Server (i.e. cache, log dirs)
 set :file_permissions_paths,         [fetch(:log_path), fetch(:cache_path), fetch(:web_path) + "/uploads", fetch(:web_path) + "/media"]
 set :file_permissions_users,        ["www-data", "eesa", "deploy"]

 # Default branch is :master
 # ask :branch, `git rev-parse --abbrev-ref HEAD`.chomp

 # Default deploy_to directory is /var/www/my_app_name
 # set :deploy_to, '/var/www/my_app_name'

 # Default value for :scm is :git
 # set :scm, :git

 # Default value for :format is :pretty
 # set :format, :pretty

 # Default value for :log_level is :debug
 # set :log_level, :debug

 # Default value for :pty is false
 # set :pty, true

 # Default value for :linked_files is []
 # set :linked_files, fetch(:linked_files, []).push('config/database.yml', 'config/secrets.yml')

 # Default value for linked_dirs is []
 # set :linked_dirs, fetch(:linked_dirs, []).push('log', 'tmp/pids', 'tmp/cache', 'tmp/sockets', 'vendor/bundle', 'public/system')

 # Default value for default_env is {}
 # set :default_env, { path: "/opt/ruby/bin:$PATH" }

 # Default value for keep_releases is 5
 # set :keep_releases, 5
diff --git a/Santander_app_config_deploy_lib_capistrano_tasks_symlink.rake b/Santander_app_config_deploy_lib_capistrano_tasks_symlink.rake
 Rake::Task['deploy:symlink:release'].clear_actions
 Rake::Task['deploy:symlink:linked_dirs'].clear_actions
 Rake::Task['deploy:symlink:linked_files'].clear_actions

 namespace :deploy do
    namespace :symlink do
        desc 'Symlink release to current'
            task :release do
                on release_roles :all do
                    tmp_current_path = release_path.parent.join(current_path.basename)
                    tmp_release_path = release_path.relative_path_from(current_path.parent)
                    execute :ln, '-s', tmp_release_path, tmp_current_path
                    execute :mv, tmp_current_path, current_path.parent
            end
        end

        desc 'Symlink linked directories'
        task :linked_dirs do
            next unless any? :linked_dirs
            on release_roles :all do
                execute :mkdir, '-p', linked_dir_parents(release_path)

                fetch(:linked_dirs).each do |dir|
                    target = release_path.join(dir)
                    tmp_source = shared_path.join(dir)
                    source = tmp_source.relative_path_from(target.parent)
                    unless test "[ -L #{target} ]"
                        if test "[ -d #{target} ]"
                            execute :rm, '-rf', target
                        end
                        execute :ln, '-s', source, target
                    end
                end
            end
        end

        desc 'Symlink linked files'
        task :linked_files do
            next unless any? :linked_files
            on release_roles :all do
                execute :mkdir, '-p', linked_file_dirs(release_path)

                fetch(:linked_files).each do |file|
                    target = release_path.join(file)
                    tmp_source = shared_path.join(file)
                    source = tmp_source.relative_path_from(target.parent)
                    unless test "[ -L #{target} ]"
                        if test "[ -f #{target} ]"
                            execute :rm, target
                        end
                        execute :ln, '-s', source, target
                    end
                end
            end
        end
    end
 end
diff --git a/Santander_app_config_deploy_production.rb b/Santander_app_config_deploy_production.rb
 set :stage, :production
 set :branch, 'master'
 set :deploy_to, '/www/deploy_dir/SantanterHubWebinar'

 # Symfony environment
 set :symfony_env,  "prod"

 # server-based syntax
 # ======================
 # Defines a single server with a list of roles and multiple properties.
 # You can define all roles on a single server, or split them:

 # server 'example.com', user: 'deploy', roles: %w{app db web}, my_property: :my_value
 # server 'example.com', user: 'deploy', roles: %w{app web}, other_property: :other_value
 # server 'db.example.com', user: 'deploy', roles: %w{db}
 server 'web01.export-entreprises.com', user: 'deploy', roles: %w{app db web}



 # role-based syntax
 # ==================

 # Defines a role with one or multiple servers. The primary server in each
 # group is considered to be the first unless any  hosts have the primary
 # property set. Specify the username and a domain or IP for the server.
 # Don't use `:all`, it's a meta role.

 # role :app, %w{[email protected]}, my_property: :my_value
 # role :web, %w{[email protected] [email protected]}, other_property: :other_value
 # role :db,  %w{[email protected]}



 # Configuration
 # =============
 # You can set any configuration variable like in config/deploy.rb
 # These variables are then only loaded and set in this stage.
 # For available Capistrano configuration variables see the documentation page.
 # http://capistranorb.com/documentation/getting-started/configuration/
 # Feel free to add new variables to customise your setup.



 # Custom SSH Options
 # ==================
 # You may pass any option but keep in mind that net/ssh understands a
 # limited set of options, consult the Net::SSH documentation.
 # http://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start
 #
 # Global options
 # --------------
 #  set :ssh_options, {
 #    keys: %w(/home/rlisowski/.ssh/id_rsa),
 #    forward_agent: false,
 #    auth_methods: %w(password)
 #  }
 #
 # The server-based syntax can be used to override options:
 # ------------------------------------
 # server 'example.com',
 #   user: 'user_name',
 #   roles: %w{web app},
 #   ssh_options: {
 #     user: 'user_name', # overrides user setting above
 #     keys: %w(/home/user_name/.ssh/id_rsa),
 #     forward_agent: false,
 #     auth_methods: %w(publickey password)
 #     # password: 'please use keys'
 #   }
diff --git a/Santander_app_config_deploy_testing.rb b/Santander_app_config_deploy_testing.rb
 set :stage, :testing
 set :branch, 'preprod'
 set :deploy_to, '/www/deploy_dir/SantanderHubWebinar'

 # Symfony environment
 set :symfony_env,  "dev"
 set :composer_install_flags, '--prefer-dist --no-interaction --optimize-autoloader'
 set :controllers_to_clear, []

 # server-based syntax
 # ======================
 # Defines a single server with a list of roles and multiple properties.
 # You can define all roles on a single server, or split them:

 # server 'example.com', user: 'deploy', roles: %w{app db web}, my_property: :my_value
 # server 'example.com', user: 'deploy', roles: %w{app web}, other_property: :other_value
 # server 'db.example.com', user: 'deploy', roles: %w{db}
 server 'newdev.export-entreprises.com', user: 'deploy', roles: %w{app db web}



 # role-based syntax
 # ==================

 # Defines a role with one or multiple servers. The primary server in each
 # group is considered to be the first unless any  hosts have the primary
 # property set. Specify the username and a domain or IP for the server.
 # Don't use `:all`, it's a meta role.

 # role :app, %w{[email protected]}, my_property: :my_value
 # role :web, %w{[email protected] [email protected]}, other_property: :other_value
 # role :db,  %w{[email protected]}



 # Configuration
 # =============
 # You can set any configuration variable like in config/deploy.rb
 # These variables are then only loaded and set in this stage.
 # For available Capistrano configuration variables see the documentation page.
 # http://capistranorb.com/documentation/getting-started/configuration/
 # Feel free to add new variables to customise your setup.



 # Custom SSH Options
 # ==================
 # You may pass any option but keep in mind that net/ssh understands a
 # limited set of options, consult the Net::SSH documentation.
 # http://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start
 #
 # Global options
 # --------------
 #  set :ssh_options, {
 #    keys: %w(/home/rlisowski/.ssh/id_rsa),
 #    forward_agent: false,
 #    auth_methods: %w(password)
 #  }
 #
 # The server-based syntax can be used to override options:
 # ------------------------------------
 # server 'example.com',
 #   user: 'user_name',
 #   roles: %w{web app},
 #   ssh_options: {
 #     user: 'user_name', # overrides user setting above
 #     keys: %w(/home/user_name/.ssh/id_rsa),
 #     forward_agent: false,
 #     auth_methods: %w(publickey password)
 #     # password: 'please use keys'
 #   }
diff --git a/Santander_app_config_doctrine.yml b/Santander_app_config_doctrine.yml
 # Doctrine Configuration
 doctrine:
    dbal:
        default_connection:   default
        connections:
            default:
                driver:   "%database_driver%"
                host:     "%database_host%"
                port:     "%database_port%"
                dbname:   "%database_name%"
                user:     "%database_user%"
                password: "%database_password%"
                charset:  UTF8
            fusion:
                driver:   "%database_driver_fusion%"
                host:     "%database_host_fusion%"
                port:     "%database_port_fusion%"
                dbname:   "%database_name_fusion%"
                user:     "%database_user_fusion%"
                password: "%database_password_fusion%"
                charset:  UTF8
            eesa:
                driver:   "%database_driver_eesa%"
                host:     "%database_host_eesa%"
                port:     "%database_port_eesa%"
                dbname:   "%database_name_eesa%"
                user:     "%database_user_eesa%"
                password: "%database_password_eesa%"
                charset:  UTF8
    orm:
        default_entity_manager: default
        entity_managers:
            default:
                connection: default
                mappings:
                    EesaCoreBundle: ~
                    EesaGeoBundle: ~
                    EesaUserBundle: ~
                    EesaMediaBundle: ~
                    EesaWebinarBundle: ~
                    EesaSantanderBundle: ~
                    EesaSanAdminBundle: ~
                    EesaGeoBundle: ~
                filters:
                    deleted:
                        class: 'Eesa\CoreBundle\Entity\Repository\Filter\DeletedFilter'
                        enabled: true
                    owned_by:
                        class: 'Eesa\CoreBundle\Entity\Repository\Filter\OwnedByFilter'
                        enabled: false
            fusion:
                connection: fusion
                mappings:
                    EesaBridgeBundle: ~
            eesa:
                connection: eesa
                mappings:
                    EesaDataBundle: ~
        auto_generate_proxy_classes: "%kernel.debug%"

 services:
    gedmo.listener.sluggable:
        class: Gedmo\Sluggable\SluggableListener
        tags:
            - { name: doctrine.event_subscriber, connection: default }
        calls:
            - [ setAnnotationReader, [ @annotation_reader ] ]
diff --git a/Santander_app_config_i18n.yml b/Santander_app_config_i18n.yml
 parameters:
  fulldomain: %domain%
diff --git a/Santander_app_config_parameters.yml b/Santander_app_config_parameters.yml
 parameters:
    database_driver: pdo_mysql
    database_host: 127.0.0.1
    database_port: null
    database_name: santander_hub_webinar
    database_user: root
    database_password: 

    database_driver_fusion: pdo_mysql
    database_host_fusion: 127.0.0.1
    database_port_fusion: null
    database_name_fusion: santander
    database_user_fusion: root
    database_password_fusion:  

    database_driver_eesa: pdo_mysql
    database_host_eesa: 127.0.0.1
    database_port_eesa: null
    database_name_eesa: general
    database_user_eesa: root
    database_password_eesa:  

    mailer_transport: smtp
    mailer_host: 127.0.0.1
    mailer_user: null
    mailer_password: null

    locale: en
    currencyBase: USD
    secret: 3955cd80e90c14e3d979fca3f404920b947aaada

    fulldomain: stn.dev
    domain: en.stn.dev
    webinarDomain: webinar.stn.dev
    adminDomain: admin.stn.dev
    cookieDomain: .stn.dev
    documentDomain: stn.dev
    stnDomain: stn.dev
    rioDomain: hub.san.dev


    mailer:
        from:
            name: 'EESA'
            mail: '[email protected]'

    santander_auth_key_b64: SvMcE61YtBCuN9Khn1p+/k+zr5FP0JNWZc2jrszXQi4=
    santander_connecting_usa_code: $X4Cbswg
    user_session_lifetime: 300

    mandrill_api_key: 80s-hDtelISY7MyVRItbKw
    #mandrill_tracking_domain: clicks.santandertrade.com
    mandrill_subaccount_priority_high: santander-prioritaire
    mandrill_subaccount_priority_medium: santander-important
    mandrill_subaccount_priority_low: santander-autre
    fusion_backoffice_baseurl: http://en.san.dev/back_office
    fusion_frontoffice_baseurl: http://_locale_.san.dev
diff --git a/Santander_app_config_parameters.yml.dist b/Santander_app_config_parameters.yml.dist
 parameters:
    database_driver: pdo_mysql
    database_host: 127.0.0.1
    database_port: null
    database_name: santander_hub_webinar
    database_user: ~
    database_password: ~

    database_driver_fusion: pdo_mysql
    database_host_fusion: 127.0.0.1
    database_port_fusion: null
    database_name_fusion: santander
    database_user_fusion: ~
    database_password_fusion: ~

    database_driver_eesa: pdo_mysql
    database_host_eesa: 127.0.0.1
    database_port_eesa: null
    database_name_eesa: general
    database_user_eesa: ~
    database_password_eesa: ~

    mailer_transport: smtp
    mailer_host: 127.0.0.1
    mailer_user: null
    mailer_password: null

    locale: en
    secret: 3955cd80e90c14e3d979fca3f404920b947aaada

    fulldomain: san.dev
    domain: san.dev
    webinarDomain: webinar.san.dev
    adminDomain: admin.san.dev
    cookieDomain: .san.dev
    documentDomain: san.dev

    mailer:
        from:
            name: 'EESA'
            mail: '[email protected]'

    santander_auth_key_b64: SvMcE61YtBCuN9Khn1p+/k+zr5FP0JNWZc2jrszXQi4=
    santander_connecting_usa_code: $X4Cbswg
    user_session_lifetime: 300

    mandrill_api_key: 80s-hDtelISY7MyVRItbKw
    #mandrill_tracking_domain: clicks.santandertrade.com
    mandrill_subaccount_priority_high: santander-prioritaire
    mandrill_subaccount_priority_medium: santander-important
    mandrill_subaccount_priority_low: santander-autre

    fusion_backoffice_baseurl: http://en.san.dev/back_office
    fusion_frontoffice_baseurl: http://_locale_.san.dev
diff --git a/Santander_app_config_routing.yml b/Santander_app_config_routing.yml
 eesa_data:
    resource: "@EesaDataBundle/Resources/config/routing.yml"
    prefix:   /

 eesa_bridge:
    resource: "@EesaBridgeBundle/Resources/config/routing.yml"
    prefix:   /

 login_check:
    path: /login_check
    defaults: { _controller: "FOSUserBundle:Security:check" }

 logout:
    path: /logout
    defaults: { _controller: "FOSUserBundle:Security:logout" }

 eesa_core:
    resource: "@EesaCoreBundle/Resources/config/routing.yml"
    prefix:   /
    options:
        i18n: false

 eesa_media:
    resource: "@EesaMediaBundle/Resources/config/routing.yml"
    prefix:   /
    options:
        i18n: false

 eesa_user:
    resource: "@EesaUserBundle/Resources/config/routing.yml"
    prefix:   /
    options:
        i18n: false

 eesa_geo:
    resource: "@EesaGeoBundle/Resources/config/routing.yml"
    prefix:   /
    options:
        i18n: false

 eesa_webinar:
    resource: "@EesaWebinarBundle/Resources/config/routing.yml"
    prefix:   /webinar
    options:
        i18n: false

 eesa_san_admin:
    resource: "@EesaSanAdminBundle/Resources/config/routing.yml"
    prefix:   /
    host: %adminDomain%
    options:
        i18n: false

 eesa_santander:
    resource: "@EesaSantanderBundle/Resources/config/routing.yml"
    prefix:   /

 _liip_imagine:
    resource: "@LiipImagineBundle/Resources/config/routing.xml"
    prefix:   /files
    options:
        i18n: false
diff --git a/Santander_app_config_routing_dev.yml b/Santander_app_config_routing_dev.yml
 _wdt:
    resource: "@WebProfilerBundle/Resources/config/routing/wdt.xml"
    prefix:   /_wdt

 _profiler:
    resource: "@WebProfilerBundle/Resources/config/routing/profiler.xml"
    prefix:   /_profiler

 _configurator:
    resource: "@SensioDistributionBundle/Resources/config/routing/webconfigurator.xml"
    prefix:   /_configurator

 _errors:
    resource: "@TwigBundle/Resources/config/routing/errors.xml"
    prefix:   /_error

 _main:
    resource: routing.yml
diff --git a/Santander_app_config_security.yml b/Santander_app_config_security.yml
 security:
    encoders:
        FOS\UserBundle\Model\UserInterface: sha512

    role_hierarchy:
        ROLE_SUPER_ADMIN: ROLE_ADMIN
        ROLE_ADMIN: [ROLE_WEBMASTER, ROLE_CLIENT]
        ROLE_WEBMASTER: ROLE_CLIENT
        ROLE_WEBINAR:
        ROLE_CLIENT: ROLE_USER

    providers:
        fos_userbundle:
            id: fos_user.user_provider.username_email

    firewalls:
        main:
            pattern: ^/
            form_login:
                provider: fos_userbundle
                #csrf_provider: form.csrf_provider
                success_handler: eesa_santander.authentication.success_handler
            logout:
                path: logout
                success_handler: eesa_santander.logout.success_handler
            anonymous:    true

    access_control:
       - { path: ^/bo/, role: ROLE_ADMIN }
diff --git a/Santander_app_config_serializer.yml b/Santander_app_config_serializer.yml
 # config.yml
 jms_serializer:
    handlers:
        datetime:
            default_format: "Y-m-d H:i:s" # ISO8601
            
    property_naming:
        separator:  _
        lower_case: true

    metadata:
        cache: file
        debug: "%kernel.debug%"
        file_cache:
            dir: "%kernel.cache_dir%/serializer"
        auto_detection: true
        directories:
            FOSUB:
                namespace_prefix: FOS\UserBundle
                path: %kernel.root_dir%/serializer/FOSUB
diff --git a/Santander_app_config_services.yml b/Santander_app_config_services.yml
 # Learn more about services, parameters and containers at
 # http://symfony.com/doc/current/book/service_container.html
 parameters:
 #    parameter_name: value

 services:
    twig.extension.text:
         class: Twig_Extensions_Extension_Text
         tags:
             - { name: twig.extension }
    twig.extension.intl:
         class: Twig_Extensions_Extension_Intl
         tags:
             - { name: twig.extension }
    twig.extension.debug:
         class: Twig_Extension_Debug
         tags:
             - { name: twig.extension }
diff --git a/Santander_app_console b/Santander_app_console
 #!/usr/bin/env php
 <?php

 // if you don't want to setup permissions the proper way, just uncomment the following PHP line
 // read http://symfony.com/doc/current/book/installation.html#configuration-and-setup for more information
 //umask(0000);

 set_time_limit(0);

 require_once __DIR__.'/bootstrap.php.cache';
 require_once __DIR__.'/AppKernel.php';

 use Symfony\Bundle\FrameworkBundle\Console\Application;
 use Symfony\Component\Console\Input\ArgvInput;
 use Symfony\Component\Debug\Debug;

 $input = new ArgvInput();
 $env = $input->getParameterOption(array('--env', '-e'), getenv('SYMFONY_ENV') ?: 'dev');
 $debug = getenv('SYMFONY_DEBUG') !== '0' && !$input->hasParameterOption(array('--no-debug', '')) && $env !== 'prod';

 if ($debug) {
    Debug::enable();
 }

 $kernel = new AppKernel($env, $debug);
 $application = new Application($kernel);
 $application->run($input);
diff --git a/Santander_app_phpunit.xml.dist b/Santander_app_phpunit.xml.dist
 <?xml version="1.0" encoding="UTF-8"?>

 <!-- http://phpunit.de/manual/4.1/en/appendixes.configuration.html -->
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
         backupGlobals="false"
         colors="true"
         bootstrap="bootstrap.php.cache"
 >
    <testsuites>
        <testsuite name="Project Test Suite">
            <directory>../src/*/*Bundle/Tests</directory>
            <directory>../src/*/Bundle/*Bundle/Tests</directory>
            <directory>../src/*Bundle/Tests</directory>
        </testsuite>
    </testsuites>

    <!--
    <php>
        <server name="KERNEL_DIR" value="/path/to/your/app/" />
    </php>
    -->

    <filter>
        <whitelist>
            <directory>../src</directory>
            <exclude>
                <directory>../src/*Bundle/Resources</directory>
                <directory>../src/*Bundle/Tests</directory>
                <directory>../src/*/*Bundle/Resources</directory>
                <directory>../src/*/*Bundle/Tests</directory>
                <directory>../src/*/Bundle/*Bundle/Resources</directory>
                <directory>../src/*/Bundle/*Bundle/Tests</directory>
            </exclude>
        </whitelist>
    </filter>
 </phpunit>
diff --git a/Santander_app_Resources_TwigBundle_views_Exception_error.html.twig b/Santander_app_Resources_TwigBundle_views_Exception_error.html.twig
 <!DOCTYPE html>
 <html>
 <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Landing page hub</title>
    <link rel="stylesheet" media="screen" href="{{ asset('front/bundle/santander/dist/css/base.min.css') }}?version=1.1">
    <link rel="icon" type="image/png" href="{{ asset('front/bundle/santander/dist/images/favicon.png') }}" />
    <!--[if lt IE 9]>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.2/html5shiv.min.js"></script>  
    <![endif]-->    
 </head>

 <body class="{% block bodyClass %}{% endblock %}">
    <div id="global">
        <header>
            <div class="toolbar"></div><!-- fin toolbar -->

            {% block header %}
                <a href="{{ path('eesa_hub_home') }}" class="logo-st"><img src="{{ asset('front/bundle/santander/dist/images/logo-santander-trade.png') }}" alt="Santander Trade"/></a>
                {% if app.user is not null and is_granted('IS_AUTHENTICATED_REMEMBERED') and app.user.profile.fullName %}
                    <h1 class="baseline">{{ 'Welcome'|trans }} {{ app.user.profile.fullName }}</h1>
                {% else %}
                    <h1 class="baseline">{{ 'Fuelling International Ambition'|trans }}</h1>
                {% endif %}
            {% endblock %}
        </header><!-- fin header -->

        <br><br><br><br>
        <section class="contenu">
            <h3><strong>{{ status_code }}</strong> {{ status_text }}</h3>
           <div class="clean"></div>
        </section><!--- fin contenu -->

        {% include 'EesaSantanderBundle:Hub:footer.html.twig' %}
    </div>

    <div class="modal fade" id="modal" aria-labelledby="modal" aria-hidden="true"></div>

    <script src="{{ asset('front/bundle/santander/dist/js/app.min.js') }}"></script>
    <script type="text/javascript">
        $.ajax({
            type: 'GET',
            url: '{{ url('eesa_hub_nav') }}',
            data: { type: "hub" },
            success: function(response) {
                $('.toolbar').html(response);
            },
            error: function(xhr, status, error) {
            }
        });
    </script>
    {% block js_bottom %}{% endblock %}
 </body>
 </html>
diff --git a/Santander_app_Resources_TwigBundle_views_layout.html.twig b/Santander_app_Resources_TwigBundle_views_layout.html.twig
 <!DOCTYPE html>
 <html>
 <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Santander Trade</title>
    <link rel="stylesheet" media="screen" href="{{ asset('front/bundle/santander/dist/css/base.min.css') }}?version=1.1">
    <link rel="icon" type="image/png" href="{{ asset('front/bundle/santander/dist/images/favicon.png') }}" />
    <!--[if lt IE 9]>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.2/html5shiv.min.js"></script>  
    <![endif]-->    
 </head>

 <body class="{% block bodyClass %}{% endblock %}">
    <div id="global">
        <header>
            <div class="toolbar"></div><!-- fin toolbar -->

            {% block header %}
                <a href="{{ path('eesa_hub_home') }}" class="logo-st"><img src="{{ asset('front/bundle/santander/dist/images/logo-santander-trade.png') }}" alt="Santander Trade"/></a>
                {% if app.user is not null and is_granted('IS_AUTHENTICATED_REMEMBERED') and app.user.profile.fullName %}
                    <h1 class="baseline">{{ 'Welcome'|trans }} {{ app.user.profile.fullName }}</h1>
                {% else %}
                    <h1 class="baseline">{{ 'Fuelling International Ambition'|trans }}</h1>
                {% endif %}
            {% endblock %}
        </header><!-- fin header -->

        {% block body %}{% endblock %}

        {% include 'EesaSantanderBundle:Hub:footer.html.twig' %}
    </div>

    <div class="modal fade" id="modal" aria-labelledby="modal" aria-hidden="true"></div>

    <script src="{{ asset('front/bundle/santander/dist/js/app.min.js') }}"></script>
    <script type="text/javascript">
        $.ajax({
            type: 'GET',
            url: '{{ url('eesa_hub_nav') }}',
            data: { type: "hub" },
            success: function(response) {
                $('.toolbar').html(response);
            },
            error: function(xhr, status, error) {
            }
        });
    </script>
    {% block js_bottom %}{% endblock %}
 </body>
 </html>
diff --git a/Santander_app_Resources_views_base.html.twig b/Santander_app_Resources_views_base.html.twig
 <!DOCTYPE html>
 <html>
    <head>
        <meta charset="UTF-8" />
        <title>{% block title %}Welcome!{% endblock %}</title>
        {% block stylesheets %}{% endblock %}
        <link rel="icon" type="image/x-icon" href="{{ asset('favicon.ico') }}" />
    </head>
    <body>
        {% block body %}{% endblock %}
        {% block javascripts %}{% endblock %}
    </body>
 </html>
diff --git a/Santander_app_SymfonyRequirements.php b/Santander_app_SymfonyRequirements.php
 <?php

 /*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

 /*
 * Users of PHP 5.2 should be able to run the requirements checks.
 * This is why the file and all classes must be compatible with PHP 5.2+
 * (e.g. not using namespaces and closures).
 *
 * ************** CAUTION **************
 *
 * DO NOT EDIT THIS FILE as it will be overridden by Composer as part of
 * the installation/update process. The original file resides in the
 * SensioDistributionBundle.
 *
 * ************** CAUTION **************
 */

 /**
 * Represents a single PHP requirement, e.g. an installed extension.
 * It can be a mandatory requirement or an optional recommendation.
 * There is a special subclass, named PhpIniRequirement, to check a php.ini configuration.
 *
 * @author Tobias Schultze <http://tobion.de>
 */
 class Requirement
 {
    private $fulfilled;
    private $testMessage;
    private $helpText;
    private $helpHtml;
    private $optional;

    /**
     * Constructor that initializes the requirement.
     *
     * @param bool        $fulfilled   Whether the requirement is fulfilled
     * @param string      $testMessage The message for testing the requirement
     * @param string      $helpHtml    The help text formatted in HTML for resolving the problem
     * @param string|null $helpText    The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     * @param bool        $optional    Whether this is only an optional recommendation not a mandatory requirement
     */
    public function __construct($fulfilled, $testMessage, $helpHtml, $helpText = null, $optional = false)
    {
        $this->fulfilled = (bool) $fulfilled;
        $this->testMessage = (string) $testMessage;
        $this->helpHtml = (string) $helpHtml;
        $this->helpText = null === $helpText ? strip_tags($this->helpHtml) : (string) $helpText;
        $this->optional = (bool) $optional;
    }

    /**
     * Returns whether the requirement is fulfilled.
     *
     * @return bool true if fulfilled, otherwise false
     */
    public function isFulfilled()
    {
        return $this->fulfilled;
    }

    /**
     * Returns the message for testing the requirement.
     *
     * @return string The test message
     */
    public function getTestMessage()
    {
        return $this->testMessage;
    }

    /**
     * Returns the help text for resolving the problem.
     *
     * @return string The help text
     */
    public function getHelpText()
    {
        return $this->helpText;
    }

    /**
     * Returns the help text formatted in HTML.
     *
     * @return string The HTML help
     */
    public function getHelpHtml()
    {
        return $this->helpHtml;
    }

    /**
     * Returns whether this is only an optional recommendation and not a mandatory requirement.
     *
     * @return bool true if optional, false if mandatory
     */
    public function isOptional()
    {
        return $this->optional;
    }
 }

 /**
 * Represents a PHP requirement in form of a php.ini configuration.
 *
 * @author Tobias Schultze <http://tobion.de>
 */
 class PhpIniRequirement extends Requirement
 {
    /**
     * Constructor that initializes the requirement.
     *
     * @param string        $cfgName           The configuration name used for ini_get()
     * @param bool|callback $evaluation        Either a boolean indicating whether the configuration should evaluate to true or false,
     *                                         or a callback function receiving the configuration value as parameter to determine the fulfillment of the requirement
     * @param bool          $approveCfgAbsence If true the Requirement will be fulfilled even if the configuration option does not exist, i.e. ini_get() returns false.
     *                                         This is helpful for abandoned configs in later PHP versions or configs of an optional extension, like Suhosin.
     *                                         Example: You require a config to be true but PHP later removes this config and defaults it to true internally.
     * @param string|null   $testMessage       The message for testing the requirement (when null and $evaluation is a boolean a default message is derived)
     * @param string|null   $helpHtml          The help text formatted in HTML for resolving the problem (when null and $evaluation is a boolean a default help is derived)
     * @param string|null   $helpText          The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     * @param bool          $optional          Whether this is only an optional recommendation not a mandatory requirement
     */
    public function __construct($cfgName, $evaluation, $approveCfgAbsence = false, $testMessage = null, $helpHtml = null, $helpText = null, $optional = false)
    {
        $cfgValue = ini_get($cfgName);

        if (is_callable($evaluation)) {
            if (null === $testMessage || null === $helpHtml) {
                throw new InvalidArgumentException('You must provide the parameters testMessage and helpHtml for a callback evaluation.');
            }

            $fulfilled = call_user_func($evaluation, $cfgValue);
        } else {
            if (null === $testMessage) {
                $testMessage = sprintf('%s %s be %s in php.ini',
                    $cfgName,
                    $optional ? 'should' : 'must',
                    $evaluation ? 'enabled' : 'disabled'
                );
            }

            if (null === $helpHtml) {
                $helpHtml = sprintf('Set <strong>%s</strong> to <strong>%s</strong> in php.ini<a href="#phpini">*</a>.',
                    $cfgName,
                    $evaluation ? 'on' : 'off'
                );
            }

            $fulfilled = $evaluation == $cfgValue;
        }

        parent::__construct($fulfilled || ($approveCfgAbsence && false === $cfgValue), $testMessage, $helpHtml, $helpText, $optional);
    }
 }

 /**
 * A RequirementCollection represents a set of Requirement instances.
 *
 * @author Tobias Schultze <http://tobion.de>
 */
 class RequirementCollection implements IteratorAggregate
 {
    private $requirements = array();

    /**
     * Gets the current RequirementCollection as an Iterator.
     *
     * @return Traversable A Traversable interface
     */
    public function getIterator()
    {
        return new ArrayIterator($this->requirements);
    }

    /**
     * Adds a Requirement.
     *
     * @param Requirement $requirement A Requirement instance
     */
    public function add(Requirement $requirement)
    {
        $this->requirements[] = $requirement;
    }

    /**
     * Adds a mandatory requirement.
     *
     * @param bool        $fulfilled   Whether the requirement is fulfilled
     * @param string      $testMessage The message for testing the requirement
     * @param string      $helpHtml    The help text formatted in HTML for resolving the problem
     * @param string|null $helpText    The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     */
    public function addRequirement($fulfilled, $testMessage, $helpHtml, $helpText = null)
    {
        $this->add(new Requirement($fulfilled, $testMessage, $helpHtml, $helpText, false));
    }

    /**
     * Adds an optional recommendation.
     *
     * @param bool        $fulfilled   Whether the recommendation is fulfilled
     * @param string      $testMessage The message for testing the recommendation
     * @param string      $helpHtml    The help text formatted in HTML for resolving the problem
     * @param string|null $helpText    The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     */
    public function addRecommendation($fulfilled, $testMessage, $helpHtml, $helpText = null)
    {
        $this->add(new Requirement($fulfilled, $testMessage, $helpHtml, $helpText, true));
    }

    /**
     * Adds a mandatory requirement in form of a php.ini configuration.
     *
     * @param string        $cfgName           The configuration name used for ini_get()
     * @param bool|callback $evaluation        Either a boolean indicating whether the configuration should evaluate to true or false,
     *                                         or a callback function receiving the configuration value as parameter to determine the fulfillment of the requirement
     * @param bool          $approveCfgAbsence If true the Requirement will be fulfilled even if the configuration option does not exist, i.e. ini_get() returns false.
     *                                         This is helpful for abandoned configs in later PHP versions or configs of an optional extension, like Suhosin.
     *                                         Example: You require a config to be true but PHP later removes this config and defaults it to true internally.
     * @param string        $testMessage       The message for testing the requirement (when null and $evaluation is a boolean a default message is derived)
     * @param string        $helpHtml          The help text formatted in HTML for resolving the problem (when null and $evaluation is a boolean a default help is derived)
     * @param string|null   $helpText          The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     */
    public function addPhpIniRequirement($cfgName, $evaluation, $approveCfgAbsence = false, $testMessage = null, $helpHtml = null, $helpText = null)
    {
        $this->add(new PhpIniRequirement($cfgName, $evaluation, $approveCfgAbsence, $testMessage, $helpHtml, $helpText, false));
    }

    /**
     * Adds an optional recommendation in form of a php.ini configuration.
     *
     * @param string        $cfgName           The configuration name used for ini_get()
     * @param bool|callback $evaluation        Either a boolean indicating whether the configuration should evaluate to true or false,
     *                                         or a callback function receiving the configuration value as parameter to determine the fulfillment of the requirement
     * @param bool          $approveCfgAbsence If true the Requirement will be fulfilled even if the configuration option does not exist, i.e. ini_get() returns false.
     *                                         This is helpful for abandoned configs in later PHP versions or configs of an optional extension, like Suhosin.
     *                                         Example: You require a config to be true but PHP later removes this config and defaults it to true internally.
     * @param string        $testMessage       The message for testing the requirement (when null and $evaluation is a boolean a default message is derived)
     * @param string        $helpHtml          The help text formatted in HTML for resolving the problem (when null and $evaluation is a boolean a default help is derived)
     * @param string|null   $helpText          The help text (when null, it will be inferred from $helpHtml, i.e. stripped from HTML tags)
     */
    public function addPhpIniRecommendation($cfgName, $evaluation, $approveCfgAbsence = false, $testMessage = null, $helpHtml = null, $helpText = null)
    {
        $this->add(new PhpIniRequirement($cfgName, $evaluation, $approveCfgAbsence, $testMessage, $helpHtml, $helpText, true));
    }

    /**
     * Adds a requirement collection to the current set of requirements.
     *
     * @param RequirementCollection $collection A RequirementCollection instance
     */
    public function addCollection(RequirementCollection $collection)
    {
        $this->requirements = array_merge($this->requirements, $collection->all());
    }

    /**
     * Returns both requirements and recommendations.
     *
     * @return array Array of Requirement instances
     */
    public function all()
    {
        return $this->requirements;
    }

    /**
     * Returns all mandatory requirements.
     *
     * @return array Array of Requirement instances
     */
    public function getRequirements()
    {
        $array = array();
        foreach ($this->requirements as $req) {
            if (!$req->isOptional()) {
                $array[] = $req;
            }
        }

        return $array;
    }

    /**
     * Returns the mandatory requirements that were not met.
     *
     * @return array Array of Requirement instances
     */
    public function getFailedRequirements()
    {
        $array = array();
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && !$req->isOptional()) {
                $array[] = $req;
            }
        }

        return $array;
    }

    /**
     * Returns all optional recommendations.
     *
     * @return array Array of Requirement instances
     */
    public function getRecommendations()
    {
        $array = array();
        foreach ($this->requirements as $req) {
            if ($req->isOptional()) {
                $array[] = $req;
            }
        }

        return $array;
    }

    /**
     * Returns the recommendations that were not met.
     *
     * @return array Array of Requirement instances
     */
    public function getFailedRecommendations()
    {
        $array = array();
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && $req->isOptional()) {
                $array[] = $req;
            }
        }

        return $array;
    }

    /**
     * Returns whether a php.ini configuration is not correct.
     *
     * @return bool php.ini configuration problem?
     */
    public function hasPhpIniConfigIssue()
    {
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && $req instanceof PhpIniRequirement) {
                return true;
            }
        }

        return false;
    }

    /**
     * Returns the PHP configuration file (php.ini) path.
     *
     * @return string|false php.ini file path
     */
    public function getPhpIniConfigPath()
    {
        return get_cfg_var('cfg_file_path');
    }
 }

 /**
 * This class specifies all requirements and optional recommendations that
 * are necessary to run the Symfony Standard Edition.
 *
 * @author Tobias Schultze <http://tobion.de>
 * @author Fabien Potencier <[email protected]>
 */
 class SymfonyRequirements extends RequirementCollection
 {
    const REQUIRED_PHP_VERSION = '5.3.3';

    /**
     * Constructor that initializes the requirements.
     */
    public function __construct()
    {
        /* mandatory requirements follow */

        $installedPhpVersion = phpversion();

        $this->addRequirement(
            version_compare($installedPhpVersion, self::REQUIRED_PHP_VERSION, '>='),
            sprintf('PHP version must be at least %s (%s installed)', self::REQUIRED_PHP_VERSION, $installedPhpVersion),
            sprintf('You are running PHP version "<strong>%s</strong>", but Symfony needs at least PHP "<strong>%s</strong>" to run.
                Before using Symfony, upgrade your PHP installation, preferably to the latest version.',
                $installedPhpVersion, self::REQUIRED_PHP_VERSION),
            sprintf('Install PHP %s or newer (installed version is %s)', self::REQUIRED_PHP_VERSION, $installedPhpVersion)
        );

        $this->addRequirement(
            version_compare($installedPhpVersion, '5.3.16', '!='),
            'PHP version must not be 5.3.16 as Symfony won\'t work properly with it',
            'Install PHP 5.3.17 or newer (or downgrade to an earlier PHP version)'
        );

        $this->addRequirement(
            is_dir(__DIR__.'/../vendor/composer'),
            'Vendor libraries must be installed',
            'Vendor libraries are missing. Install composer following instructions from <a href="http://getcomposer.org/">http://getcomposer.org/</a>. '.
                'Then run "<strong>php composer.phar install</strong>" to install them.'
        );

        $cacheDir = is_dir(__DIR__.'/../var/cache') ? __DIR__.'/../var/cache' : __DIR__.'/cache';

        $this->addRequirement(
            is_writable($cacheDir),
            'app/cache/ or var/cache/ directory must be writable',
            'Change the permissions of either "<strong>app/cache/</strong>" or  "<strong>var/cache/</strong>" directory so that the web server can write into it.'
        );

        $logsDir = is_dir(__DIR__.'/../var/logs') ? __DIR__.'/../var/logs' : __DIR__.'/logs';

        $this->addRequirement(
            is_writable($logsDir),
            'app/logs/ or var/logs/ directory must be writable',
            'Change the permissions of either "<strong>app/logs/</strong>" or  "<strong>var/logs/</strong>" directory so that the web server can write into it.'
        );

        $this->addPhpIniRequirement(
            'date.timezone', true, false,
            'date.timezone setting must be set',
            'Set the "<strong>date.timezone</strong>" setting in php.ini<a href="#phpini">*</a> (like Europe/Paris).'
        );

        if (version_compare($installedPhpVersion, self::REQUIRED_PHP_VERSION, '>=')) {
            $timezones = array();
            foreach (DateTimeZone::listAbbreviations() as $abbreviations) {
                foreach ($abbreviations as $abbreviation) {
                    $timezones[$abbreviation['timezone_id']] = true;
                }
            }

            $this->addRequirement(
                isset($timezones[@date_default_timezone_get()]),
                sprintf('Configured default timezone "%s" must be supported by your installation of PHP', @date_default_timezone_get()),
                'Your default timezone is not supported by PHP. Check for typos in your <strong>php.ini</strong> file and have a look at the list of deprecated timezones at <a href="http://php.net/manual/en/timezones.others.php">http://php.net/manual/en/timezones.others.php</a>.'
            );
        }

        $this->addRequirement(
            function_exists('json_encode'),
            'json_encode() must be available',
            'Install and enable the <strong>JSON</strong> extension.'
        );

        $this->addRequirement(
            function_exists('session_start'),
            'session_start() must be available',
            'Install and enable the <strong>session</strong> extension.'
        );

        $this->addRequirement(
            function_exists('ctype_alpha'),
            'ctype_alpha() must be available',
            'Install and enable the <strong>ctype</strong> extension.'
        );

        $this->addRequirement(
            function_exists('token_get_all'),
            'token_get_all() must be available',
            'Install and enable the <strong>Tokenizer</strong> extension.'
        );

        $this->addRequirement(
            function_exists('simplexml_import_dom'),
            'simplexml_import_dom() must be available',
            'Install and enable the <strong>SimpleXML</strong> extension.'
        );

        if (function_exists('apc_store') && ini_get('apc.enabled')) {
            if (version_compare($installedPhpVersion, '5.4.0', '>=')) {
                $this->addRequirement(
                    version_compare(phpversion('apc'), '3.1.13', '>='),
                    'APC version must be at least 3.1.13 when using PHP 5.4',
                    'Upgrade your <strong>APC</strong> extension (3.1.13+).'
                );
            } else {
                $this->addRequirement(
                    version_compare(phpversion('apc'), '3.0.17', '>='),
                    'APC version must be at least 3.0.17',
                    'Upgrade your <strong>APC</strong> extension (3.0.17+).'
                );
            }
        }

        $this->addPhpIniRequirement('detect_unicode', false);

        if (extension_loaded('suhosin')) {
            $this->addPhpIniRequirement(
                'suhosin.executor.include.whitelist',
                create_function('$cfgValue', 'return false !== stripos($cfgValue, "phar");'),
                false,
                'suhosin.executor.include.whitelist must be configured correctly in php.ini',
                'Add "<strong>phar</strong>" to <strong>suhosin.executor.include.whitelist</strong> in php.ini<a href="#phpini">*</a>.'
            );
        }

        if (extension_loaded('xdebug')) {
            $this->addPhpIniRequirement(
                'xdebug.show_exception_trace', false, true
            );

            $this->addPhpIniRequirement(
                'xdebug.scream', false, true
            );

            $this->addPhpIniRecommendation(
                'xdebug.max_nesting_level',
                create_function('$cfgValue', 'return $cfgValue > 100;'),
                true,
                'xdebug.max_nesting_level should be above 100 in php.ini',
                'Set "<strong>xdebug.max_nesting_level</strong>" to e.g. "<strong>250</strong>" in php.ini<a href="#phpini">*</a> to stop Xdebug\'s infinite recursion protection erroneously throwing a fatal error in your project.'
            );
        }

        $pcreVersion = defined('PCRE_VERSION') ? (float) PCRE_VERSION : null;

        $this->addRequirement(
            null !== $pcreVersion,
            'PCRE extension must be available',
            'Install the <strong>PCRE</strong> extension (version 8.0+).'
        );

        if (extension_loaded('mbstring')) {
            $this->addPhpIniRequirement(
                'mbstring.func_overload',
                create_function('$cfgValue', 'return (int) $cfgValue === 0;'),
                true,
                'string functions should not be overloaded',
                'Set "<strong>mbstring.func_overload</strong>" to <strong>0</strong> in php.ini<a href="#phpini">*</a> to disable function overloading by the mbstring extension.'
            );
        }

        /* optional recommendations follow */

        if (file_exists(__DIR__.'/../vendor/composer')) {
            require_once __DIR__.'/../vendor/autoload.php';

            try {
                $r = new \ReflectionClass('Sensio\Bundle\DistributionBundle\SensioDistributionBundle');

                $contents = file_get_contents(dirname($r->getFileName()).'/Resources/skeleton/app/SymfonyRequirements.php');
            } catch (\ReflectionException $e) {
                $contents = '';
            }
            $this->addRecommendation(
                file_get_contents(__FILE__) === $contents,
                'Requirements file should be up-to-date',
                'Your requirements file is outdated. Run composer install and re-check your configuration.'
            );
        }

        $this->addRecommendation(
            version_compare($installedPhpVersion, '5.3.4', '>='),
            'You should use at least PHP 5.3.4 due to PHP bug #52083 in earlier versions',
            'Your project might malfunction randomly due to PHP bug #52083 ("Notice: Trying to get property of non-object"). Install PHP 5.3.4 or newer.'
        );

        $this->addRecommendation(
            version_compare($installedPhpVersion, '5.3.8', '>='),
            'When using annotations you should have at least PHP 5.3.8 due to PHP bug #55156',
            'Install PHP 5.3.8 or newer if your project uses annotations.'
        );

        $this->addRecommendation(
            version_compare($installedPhpVersion, '5.4.0', '!='),
            'You should not use PHP 5.4.0 due to the PHP bug #61453',
            'Your project might not work properly due to the PHP bug #61453 ("Cannot dump definitions which have method calls"). Install PHP 5.4.1 or newer.'
        );

        $this->addRecommendation(
            version_compare($installedPhpVersion, '5.4.11', '>='),
            'When using the logout handler from the Symfony Security Component, you should have at least PHP 5.4.11 due to PHP bug #63379 (as a workaround, you can also set invalidate_session to false in the security logout handler configuration)',
            'Install PHP 5.4.11 or newer if your project uses the logout handler from the Symfony Security Component.'
        );

        $this->addRecommendation(
            (version_compare($installedPhpVersion, '5.3.18', '>=') && version_compare($installedPhpVersion, '5.4.0', '<'))
            ||
            version_compare($installedPhpVersion, '5.4.8', '>='),
            'You should use PHP 5.3.18+ or PHP 5.4.8+ to always get nice error messages for fatal errors in the development environment due to PHP bug #61767/#60909',
            'Install PHP 5.3.18+ or PHP 5.4.8+ if you want nice error messages for all fatal errors in the development environment.'
        );

        if (null !== $pcreVersion) {
            $this->addRecommendation(
                $pcreVersion >= 8.0,
                sprintf('PCRE extension should be at least version 8.0 (%s installed)', $pcreVersion),
                '<strong>PCRE 8.0+</strong> is preconfigured in PHP since 5.3.2 but you are using an outdated version of it. Symfony probably works anyway but it is recommended to upgrade your PCRE extension.'
            );
        }

        $this->addRecommendation(
            class_exists('DomDocument'),
            'PHP-DOM and PHP-XML modules should be installed',
            'Install and enable the <strong>PHP-DOM</strong> and the <strong>PHP-XML</strong> modules.'
        );

        $this->addRecommendation(
            function_exists('mb_strlen'),
            'mb_strlen() should be available',
            'Install and enable the <strong>mbstring</strong> extension.'
        );

        $this->addRecommendation(
            function_exists('iconv'),
            'iconv() should be available',
            'Install and enable the <strong>iconv</strong> extension.'
        );

        $this->addRecommendation(
            function_exists('utf8_decode'),
            'utf8_decode() should be available',
            'Install and enable the <strong>XML</strong> extension.'
        );

        $this->addRecommendation(
            function_exists('filter_var'),
            'filter_var() should be available',
            'Install and enable the <strong>filter</strong> extension.'
        );

        if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
            $this->addRecommendation(
                function_exists('posix_isatty'),
                'posix_isatty() should be available',
                'Install and enable the <strong>php_posix</strong> extension (used to colorize the CLI output).'
            );
        }

        $this->addRecommendation(
            class_exists('Locale'),
            'intl extension should be available',
            'Install and enable the <strong>intl</strong> extension (used for validators).'
        );

        if (extension_loaded('intl')) {
            // in some WAMP server installations, new Collator() returns null
            $this->addRecommendation(
                null !== new Collator('fr_FR'),
                'intl extension should be correctly configured',
                'The intl extension does not behave properly. This problem is typical on PHP 5.3.X x64 WIN builds.'
            );

            // check for compatible ICU versions (only done when you have the intl extension)
            if (defined('INTL_ICU_VERSION')) {
                $version = INTL_ICU_VERSION;
            } else {
                $reflector = new ReflectionExtension('intl');

                ob_start();
                $reflector->info();
                $output = strip_tags(ob_get_clean());

                preg_match('/^ICU version +(?:=> )?(.*)$/m', $output, $matches);
                $version = $matches[1];
            }

            $this->addRecommendation(
                version_compare($version, '4.0', '>='),
                'intl ICU version should be at least 4+',
                'Upgrade your <strong>intl</strong> extension with a newer ICU version (4+).'
            );

            $this->addPhpIniRecommendation(
                'intl.error_level',
                create_function('$cfgValue', 'return (int) $cfgValue === 0;'),
                true,
                'intl.error_level should be 0 in php.ini',
                'Set "<strong>intl.error_level</strong>" to "<strong>0</strong>" in php.ini<a href="#phpini">*</a> to inhibit the messages when an error occurs in ICU functions.'
            );
        }

        $accelerator =
            (extension_loaded('eaccelerator') && ini_get('eaccelerator.enable'))
            ||
            (extension_loaded('apc') && ini_get('apc.enabled'))
            ||
            (extension_loaded('Zend Optimizer+') && ini_get('zend_optimizerplus.enable'))
            ||
            (extension_loaded('Zend OPcache') && ini_get('opcache.enable'))
            ||
            (extension_loaded('xcache') && ini_get('xcache.cacher'))
            ||
            (extension_loaded('wincache') && ini_get('wincache.ocenabled'))
        ;

        $this->addRecommendation(
            $accelerator,
            'a PHP accelerator should be installed',
            'Install and/or enable a <strong>PHP accelerator</strong> (highly recommended).'
        );

        if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
            $this->addRecommendation(
                $this->getRealpathCacheSize() > 1000,
                'realpath_cache_size should be above 1024 in php.ini',
                'Set "<strong>realpath_cache_size</strong>" to e.g. "<strong>1024</strong>" in php.ini<a href="#phpini">*</a> to improve performance on windows.'
            );
        }

        $this->addPhpIniRecommendation('short_open_tag', false);

        $this->addPhpIniRecommendation('magic_quotes_gpc', false, true);

        $this->addPhpIniRecommendation('register_globals', false, true);

        $this->addPhpIniRecommendation('session.auto_start', false);

        $this->addRecommendation(
            class_exists('PDO'),
            'PDO should be installed',
            'Install <strong>PDO</strong> (mandatory for Doctrine).'
        );

        if (class_exists('PDO')) {
            $drivers = PDO::getAvailableDrivers();
            $this->addRecommendation(
                count($drivers) > 0,
                sprintf('PDO should have some drivers installed (currently available: %s)', count($drivers) ? implode(', ', $drivers) : 'none'),
                'Install <strong>PDO drivers</strong> (mandatory for Doctrine).'
            );
        }
    }

    /**
     * Loads realpath_cache_size from php.ini and converts it to int.
     *
     * (e.g. 16k is converted to 16384 int)
     *
     * @return int
     */
    protected function getRealpathCacheSize()
    {
        $size = ini_get('realpath_cache_size');
        $size = trim($size);
        $unit = strtolower(substr($size, -1, 1));
        switch ($unit) {
            case 'g':
                return $size * 1024 * 1024 * 1024;
            case 'm':
                return $size * 1024 * 1024;
            case 'k':
                return $size * 1024;
            default:
                return (int) $size;
        }
    }
 }
diff --git a/Santander_build.xml b/Santander_build.xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project name="Santander hub webinar" basedir="." default="build:main">
    <!-- Properties -->
    <property name="dir.app" value="${project.basedir}/app" />
    <property name="dir.src" value="${project.basedir}/src" />
    <property name="dir.build" value="${project.basedir}/app/build" />
    <property name="dir.docs" value="${dir.build}/docs" />
    <property name="dir.docs.phpdoc" value="${dir.docs}/phpdoc" />
    <property name="dir.reports" value="${dir.build}/logs" />
    <property name="dir.reports.pdepend" value="${dir.reports}/pdepend" />
    <property name="dir.reports.coverage" value="${dir.reports}/coverage" />
    <property name="dir.reports.codebrowser" value="${dir.reports}/code-browser" />

    <!-- Filesets -->
    <fileset id="sourcecode" dir="${dir.src}">
        <include name="**/*.php" />
    </fileset>

    <!-- Default target -->
    <target name="build:main"
            depends="build:clean, build:prepare, build:composer, build:check, build:test, build:doc"
            description="Run all test and build everything" />

    <!-- Doc target -->
    <target name="build:doc"
            depends="build:prepare, doc:phpdoc"
            description="Generates app API documentation." />

    <!-- Check target -->
    <target name="build:check"
            depends="check:cs, check:md, check:cpd, check:depend, check:phploc, check:phpcb"
            description="Analyzes app code." />

    <!-- Test target -->
    <target name="build:test"
            depends="test:unit"
            description="Executes all tests.." />

    <!-- Project build clean -->
    <target name="build:clean" description="Clean up build directories.">
        <echo msg="Cleaning build directories ..." />
        <delete dir="${dir.build}" verbose="true" />
        <delete file="${dir.app}/config/parameters.yml" verbose="true" />
    </target>

    <!-- Project build prepare -->
    <target name="build:prepare" description="Create build directories.">
        <echo msg="Creating build directories ..." />
        <mkdir dir="${dir.build}" />
        <mkdir dir="${dir.docs}" />
        <mkdir dir="${dir.docs.phpdoc}" />
        <mkdir dir="${dir.reports}" />
        <mkdir dir="${dir.reports.coverage}" />
        <mkdir dir="${dir.reports.pdepend}" />
        <mkdir dir="${dir.reports.codebrowser}" />

        <copy file="${dir.app}/config/parameters.yml.dist" tofile="${dir.app}/config/parameters.yml" />
    </target>

    <!-- Composer install -->
    <target name="build:composer" description="Installing dependencies">
        <echo msg="Installing dependencies with composer ..." />
        <exec executable="composer">
            <arg value="install" />
            <arg value="--no-interaction"/>
        </exec>
    </target>

    <!-- PHPDOC2 API documentation target -->
    <target name="doc:phpdoc" description="Generate API documentation.">
        <echo msg="Generating API documentation with PHPDoc..." />
        <phpdoc2 title="${phing.project.name} :: API Documentation"
                defaultPackageName="${phing.project.name}"
                destdir="${dir.docs.phpdoc}">
            <fileset refid="sourcecode" />
        </phpdoc2>
    </target>

    <!-- PHP CodeBrowser -->
    <target name="check:phpcb" description="Aggregate tool output with PHP_CodeBrowser">
        <echo msg="Aggregate tool output with PHP_CodeBrowser ..." />
        <exec executable="phpcb">
            <arg value="--log" />
            <arg path="${dir.reports}" />
            <arg value="--source" />
            <arg path="${dir.src}" />
            <arg value="--output" />
            <arg path="${dir.reports.codebrowser}" />
        </exec>
    </target>

    <!-- PSR2 code sniffer -->
    <target name="check:cs" description="Checks coding standard.">
        <echo msg="Checking coding standard ..." />
        <phpcodesniffer standard="PSR2"
                        showSniffs="true"
                        showWarnings="true">
            <fileset refid="sourcecode" />
            <formatter type="checkstyle" outfile="${dir.reports}/checkstyle.xml" />
        </phpcodesniffer>
    </target>

    <!-- copy/paste detector -->
    <target name="check:cpd" description="Checks similar code blocks.">
        <echo msg="Checking similar code blocks ..." />
        <phpcpd>
            <fileset refid="sourcecode" />
            <formatter type="pmd" outfile="${dir.reports}/pmd-cpd.xml" />
        </phpcpd>
    </target>

    <!-- Mess detector -->
    <target name="check:md" description="Generate code metrics.">
        <echo msg="Generating code metrics ..." />
        <phpmd rulesets="codesize,unusedcode">
            <fileset refid="sourcecode" />
            <formatter type="xml" outfile="${dir.reports}/pmd.xml" />
        </phpmd>
    </target>

    <!-- Code dependency -->
    <target name="check:depend" description="Checks coupling and dependency.">
        <echo msg="Checking coupling and dependency ..." />
        <phpdepend>
            <fileset refid="sourcecode" />
            <logger type="jdepend-xml" outfile="${dir.reports.pdepend}/jdepend.xml" />
            <logger type="jdepend-chart" outfile="${dir.reports.pdepend}/dependencies.svg" />
            <logger type="overview-pyramid" outfile="${dir.reports.pdepend}/overview-pyramid.svg" />
        </phpdepend>
    </target>

    <!-- PHPLoc -->
    <target name="check:phploc" description="Measures and logs the size of the project.">
        <echo msg="Measuring and analyzing the struture ..." />
        <phploc reportType="csv" reportDirectory="${dir.reports}" reportName="phploc">
            <fileset refid="sourcecode" />
        </phploc>
    </target>

    <!-- Unit tests -->
    <target name="test:unit" description="Executes unit tests.">
        <echo msg="Running unit tests ..." />
        <exec command="phpunit --log-junit ${dir.reports}/phpunit.xml --coverage-clover ${dir.reports.coverage}/clover.xml --coverage-html ${dir.reports.coverage}/ -c ${dir.app}"/>
    </target>

 </project>
diff --git a/Santander_Capfile b/Santander_Capfile
 set :deploy_config_path, 'app/config/deploy.rb'
 set :stage_config_path, 'app/config/deploy'

 # Load DSL and set up stages
 require 'capistrano/setup'

 # Include default deployment tasks
 require 'capistrano/deploy'
 require 'capistrano/symfony'

 # Include tasks from other gems included in your Gemfile
 #
 # For documentation on these, see for example:
 #
 #   https://github.com/capistrano/rvm
 #   https://github.com/capistrano/rbenv
 #   https://github.com/capistrano/chruby
 #   https://github.com/capistrano/bundler
 #   https://github.com/capistrano/rails
 #   https://github.com/capistrano/passenger
 #
 # require 'capistrano/rvm'
 # require 'capistrano/rbenv'
 # require 'capistrano/chruby'
 # require 'capistrano/bundler'
 # require 'capistrano/rails/assets'
 # require 'capistrano/rails/migrations'
 # require 'capistrano/passenger'

 # Load custom tasks from `lib/capistrano/tasks` if you have any defined
 Dir.glob('app/config/deploy_lib/capistrano/tasks/*.rake').each { |r| import r }
diff --git a/Santander_composer.json b/Santander_composer.json
 {
    "name": "eesa/santander",
    "type": "project",
    "description": "Project santanter with sf2",
    "autoload": {
        "psr-0": { "": "src/", "SymfonyStandard": "app/" }
    },
    "require": {
        "php": ">=5.3.3",
        "symfony/symfony": "2.6.*",
        "doctrine/orm": "~2.2,>=2.2.3",
        "doctrine/doctrine-bundle": "~1.2",
        "twig/extensions": "~1.0",
        "symfony/assetic-bundle": "~2.3",
        "symfony/swiftmailer-bundle": "~2.3",
        "symfony/monolog-bundle": "~2.4",
        "symfony/intl": "3.0.*@dev",
        "sensio/distribution-bundle": "~3.0",
        "sensio/framework-extra-bundle": "~3.0",
        "gedmo/doctrine-extensions": "dev-master",
        "knplabs/doctrine-behaviors": "dev-master",
        "jms/di-extra-bundle": "dev-master",
        "jms/security-extra-bundle": "dev-master",
        "jms/serializer-bundle": "dev-master",
        "liuggio/excelbundle": "~2.0",
        "lexik/translation-bundle": "2.*@dev",
        "friendsofsymfony/user-bundle": "~2.0@dev",
        "lexik/translation-bundle": "2.*@dev",
        "lexik/form-filter-bundle": "~3.0",
        "jms/i18n-routing-bundle": "dev-master",
        "knplabs/knp-paginator-bundle": "~2.4",
        "a2lix/translation-form-bundle": "~2.0",
        "liip/imagine-bundle": "~1.2",
        "genemu/form-bundle": "^2.2",
        "accord/mandrill-swiftmailer-bundle": "^1.0",
        "google/apiclient": "1.0.*@beta",
        "liuggio/excelbundle": "~2.0",
        "evolution7/bugsnag-bundle": "1.*"
    },
    "require-dev": {
        "sensio/generator-bundle": "~2.3"
    },
    "scripts": {
        "post-root-package-install": [
            "SymfonyStandard\\Composer::hookRootPackageInstall"
        ],
        "post-install-cmd": [
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::removeSymfonyStandardFiles"
        ],
        "post-update-cmd": [
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::removeSymfonyStandardFiles"
        ]
    },
    "config": {
        "bin-dir": "bin",
        "github-oauth": {
            "github.com": "c6d3886cf7f70a910abd5062d09f8dc4c684265a"
        }
    },
    "extra": {
        "symfony-app-dir": "app",
        "symfony-web-dir": "web",
        "branch-alias": {
            "dev-master": "2.5-dev"
        }
    }
 }
diff --git a/Santander_composer.lock b/Santander_composer.lock
 {
    "_readme": [
        "This file locks the dependencies of your project to a known state",
        "Read more about it at http://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
        "This file is @generated automatically"
    ],
    "hash": "702d4674b700fbfd9b2922c7ab132296",
    "packages": [
        {
            "name": "a2lix/translation-form-bundle",
            "version": "2.0.4",
            "target-dir": "A2lix/TranslationFormBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/a2lix/TranslationFormBundle.git",
                "reference": "390e32745ddcce5308e672e8d188b6963c41de21"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/a2lix/TranslationFormBundle/zipball/390e32745ddcce5308e672e8d188b6963c41de21",
                "reference": "390e32745ddcce5308e672e8d188b6963c41de21",
                "shasum": ""
            },
            "require": {
                "symfony/symfony": ">=2.3"
            },
            "require-dev": {
                "doctrine/common": "~2.3",
                "gedmo/doctrine-extensions": "dev-wip-v2.4.0",
                "knplabs/doctrine-behaviors": "1.0.x-dev",
                "phpunit/phpunit": "~4.1"
            },
            "suggest": {
                "a2lix/i18n-doctrine-bundle": "For A2lix strategy",
                "gedmo/doctrine-extensions": "For Gedmo strategy",
                "knplabs/doctrine-behaviors": "For Knp strategy",
                "prezent/doctrine-translatable-bundle": "For Prezent strategy"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "A2lix\\TranslationFormBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "David ALLIX",
                    "homepage": "http://a2lix.fr"
                }
            ],
            "description": "Translate your doctrine objects easily with some helps",
            "homepage": "https://github.com/a2lix/TranslationFormBundle",
            "keywords": [
                "Symfony2",
                "doctrine2",
                "form",
                "gedmo",
                "i18n",
                "internationalization",
                "knplabs",
                "translatable",
                "translation"
            ],
            "time": "2014-12-02 12:51:30"
        },
        {
            "name": "accord/mandrill-swiftmailer-bundle",
            "version": "1.1.0",
            "target-dir": "Accord/MandrillSwiftMailerBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/AccordGroup/MandrillSwiftMailerBundle.git",
                "reference": "e04e46a39e8e348267696c82812cfd8334821ed4"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/AccordGroup/MandrillSwiftMailerBundle/zipball/e04e46a39e8e348267696c82812cfd8334821ed4",
                "reference": "e04e46a39e8e348267696c82812cfd8334821ed4",
                "shasum": ""
            },
            "require": {
                "mandrill/mandrill": "~1.0",
                "php": ">=5.3.3",
                "swiftmailer/swiftmailer": "~5.3",
                "symfony/framework-bundle": ">=2.3",
                "symfony/swiftmailer-bundle": ">=2.3"
            },
            "require-dev": {
                "phpunit/phpunit": "~4.5",
                "symfony/config": ">=2.3",
                "symfony/finder": ">=2.3"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Accord\\MandrillSwiftMailerBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "GPL-2.0+"
            ],
            "authors": [
                {
                    "name": "James Rattue",
                    "email": "[email protected]"
                },
                {
                    "name": "James Willans",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony bundle to provide a Mandrill SwiftMailer service",
            "homepage": "https://github.com/AccordGroup/MandrillSwiftMailerBundle",
            "keywords": [
                "bundle",
                "mandill",
                "swiftmailer",
                "symfony"
            ],
            "time": "2015-05-22 10:18:20"
        },
        {
            "name": "behat/transliterator",
            "version": "v1.0.1",
            "source": {
                "type": "git",
                "url": "https://github.com/Behat/Transliterator.git",
                "reference": "c93521d3462a554332d1ef5bb0e9b5b8ca4106c4"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/Behat/Transliterator/zipball/c93521d3462a554332d1ef5bb0e9b5b8ca4106c4",
                "reference": "c93521d3462a554332d1ef5bb0e9b5b8ca4106c4",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.3"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Behat\\Transliterator": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Artistic-1.0"
            ],
            "description": "String transliterator",
            "keywords": [
                "i18n",
                "slug",
                "transliterator"
            ],
            "time": "2014-05-15 22:08:22"
        },
        {
            "name": "bugsnag/bugsnag",
            "version": "v2.5.4",
            "source": {
                "type": "git",
                "url": "https://github.com/bugsnag/bugsnag-php.git",
                "reference": "f013ca96b359a9675358710a52ba1aee6c508925"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/bugsnag/bugsnag-php/zipball/f013ca96b359a9675358710a52ba1aee6c508925",
                "reference": "f013ca96b359a9675358710a52ba1aee6c508925",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2.0"
            },
            "require-dev": {
                "phpunit/phpunit": "3.7.*"
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "Bugsnag_": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "James Smith",
                    "email": "[email protected]",
                    "homepage": "https://bugsnag.com"
                }
            ],
            "description": "Official Bugsnag notifier for PHP applications.",
            "homepage": "https://github.com/bugsnag/bugsnag-php",
            "keywords": [
                "bugsnag",
                "errors",
                "exceptions",
                "logging",
                "tracking"
            ],
            "time": "2015-04-13 19:09:41"
        },
        {
            "name": "doctrine/annotations",
            "version": "v1.2.4",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/annotations.git",
                "reference": "b5202eb9e83f8db52e0e58867e0a46e63be8332e"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/annotations/zipball/b5202eb9e83f8db52e0e58867e0a46e63be8332e",
                "reference": "b5202eb9e83f8db52e0e58867e0a46e63be8332e",
                "shasum": ""
            },
            "require": {
                "doctrine/lexer": "1.*",
                "php": ">=5.3.2"
            },
            "require-dev": {
                "doctrine/cache": "1.*",
                "phpunit/phpunit": "4.*"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.3.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\Annotations\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Docblock Annotations Parser",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "annotations",
                "docblock",
                "parser"
            ],
            "time": "2014-12-23 22:40:37"
        },
        {
            "name": "doctrine/cache",
            "version": "v1.4.1",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/cache.git",
                "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/cache/zipball/c9eadeb743ac6199f7eec423cb9426bc518b7b03",
                "reference": "c9eadeb743ac6199f7eec423cb9426bc518b7b03",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "conflict": {
                "doctrine/common": ">2.2,<2.4"
            },
            "require-dev": {
                "phpunit/phpunit": ">=3.7",
                "predis/predis": "~1.0",
                "satooshi/php-coveralls": "~0.6"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.5.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\Cache\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Caching library offering an object-oriented API for many cache backends",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "cache",
                "caching"
            ],
            "time": "2015-04-15 00:11:59"
        },
        {
            "name": "doctrine/collections",
            "version": "v1.3.0",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/collections.git",
                "reference": "6c1e4eef75f310ea1b3e30945e9f06e652128b8a"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/collections/zipball/6c1e4eef75f310ea1b3e30945e9f06e652128b8a",
                "reference": "6c1e4eef75f310ea1b3e30945e9f06e652128b8a",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "require-dev": {
                "phpunit/phpunit": "~4.0"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.2.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\Collections\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Collections Abstraction library",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "array",
                "collections",
                "iterator"
            ],
            "time": "2015-04-14 22:21:58"
        },
        {
            "name": "doctrine/common",
            "version": "v2.5.0",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/common.git",
                "reference": "cd8daf2501e10c63dced7b8b9b905844316ae9d3"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/common/zipball/cd8daf2501e10c63dced7b8b9b905844316ae9d3",
                "reference": "cd8daf2501e10c63dced7b8b9b905844316ae9d3",
                "shasum": ""
            },
            "require": {
                "doctrine/annotations": "1.*",
                "doctrine/cache": "1.*",
                "doctrine/collections": "1.*",
                "doctrine/inflector": "1.*",
                "doctrine/lexer": "1.*",
                "php": ">=5.3.2"
            },
            "require-dev": {
                "phpunit/phpunit": "~3.7"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.6.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Common Library for Doctrine projects",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "annotations",
                "collections",
                "eventmanager",
                "persistence",
                "spl"
            ],
            "time": "2015-04-02 19:55:44"
        },
        {
            "name": "doctrine/dbal",
            "version": "v2.5.1",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/dbal.git",
                "reference": "628c2256b646ae2417d44e063bce8aec5199d48d"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/dbal/zipball/628c2256b646ae2417d44e063bce8aec5199d48d",
                "reference": "628c2256b646ae2417d44e063bce8aec5199d48d",
                "shasum": ""
            },
            "require": {
                "doctrine/common": ">=2.4,<2.6-dev",
                "php": ">=5.3.2"
            },
            "require-dev": {
                "phpunit/phpunit": "4.*",
                "symfony/console": "2.*"
            },
            "suggest": {
                "symfony/console": "For helpful console commands such as SQL execution and import of files."
            },
            "bin": [
                "bin/doctrine-dbal"
            ],
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.5.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\DBAL\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                }
            ],
            "description": "Database Abstraction Layer",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "database",
                "dbal",
                "persistence",
                "queryobject"
            ],
            "time": "2015-01-12 21:52:47"
        },
        {
            "name": "doctrine/doctrine-bundle",
            "version": "v1.4.0",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/DoctrineBundle.git",
                "reference": "1986ff3a945b584c6505d07eae92d77e41131078"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/DoctrineBundle/zipball/1986ff3a945b584c6505d07eae92d77e41131078",
                "reference": "1986ff3a945b584c6505d07eae92d77e41131078",
                "shasum": ""
            },
            "require": {
                "doctrine/dbal": "~2.3",
                "doctrine/doctrine-cache-bundle": "~1.0",
                "jdorn/sql-formatter": "~1.1",
                "php": ">=5.3.2",
                "symfony/doctrine-bridge": "~2.2",
                "symfony/framework-bundle": "~2.3"
            },
            "require-dev": {
                "doctrine/orm": "~2.3",
                "phpunit/phpunit": "~4",
                "satooshi/php-coveralls": "~0.6.1",
                "symfony/validator": "~2.2",
                "symfony/yaml": "~2.2",
                "twig/twig": "~1.10"
            },
            "suggest": {
                "doctrine/orm": "The Doctrine ORM integration is optional in the bundle.",
                "symfony/web-profiler-bundle": "to use the data collector"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.4.x-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Doctrine\\Bundle\\DoctrineBundle\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Symfony Community",
                    "homepage": "http://symfony.com/contributors"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Doctrine Project",
                    "homepage": "http://www.doctrine-project.org/"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony DoctrineBundle",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "database",
                "dbal",
                "orm",
                "persistence"
            ],
            "time": "2015-02-28 11:04:45"
        },
        {
            "name": "doctrine/doctrine-cache-bundle",
            "version": "v1.0.1",
            "target-dir": "Doctrine/Bundle/DoctrineCacheBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/DoctrineCacheBundle.git",
                "reference": "e4b6f810aa047f9cbfe41c3d6a3d7e83d7477a9d"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/DoctrineCacheBundle/zipball/e4b6f810aa047f9cbfe41c3d6a3d7e83d7477a9d",
                "reference": "e4b6f810aa047f9cbfe41c3d6a3d7e83d7477a9d",
                "shasum": ""
            },
            "require": {
                "doctrine/cache": "~1.3",
                "doctrine/inflector": "~1.0",
                "php": ">=5.3.2",
                "symfony/doctrine-bridge": "~2.2",
                "symfony/framework-bundle": "~2.2",
                "symfony/security": "~2.2"
            },
            "require-dev": {
                "instaclick/coding-standard": "~1.1",
                "instaclick/object-calisthenics-sniffs": "dev-master",
                "instaclick/symfony2-coding-standard": "dev-remaster",
                "phpunit/phpunit": "~3.7",
                "satooshi/php-coveralls": "~0.6.1",
                "squizlabs/php_codesniffer": "dev-master",
                "symfony/console": "~2.2",
                "symfony/finder": "~2.2",
                "symfony/validator": "~2.2",
                "symfony/yaml": "~2.2"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Bundle\\DoctrineCacheBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Symfony Community",
                    "homepage": "http://symfony.com/contributors"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Fabio B. Silva",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Doctrine Project",
                    "homepage": "http://www.doctrine-project.org/"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony2 Bundle for Doctrine Cache",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "cache",
                "caching"
            ],
            "time": "2014-11-28 09:43:36"
        },
        {
            "name": "doctrine/inflector",
            "version": "v1.0.1",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/inflector.git",
                "reference": "0bcb2e79d8571787f18b7eb036ed3d004908e604"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/inflector/zipball/0bcb2e79d8571787f18b7eb036ed3d004908e604",
                "reference": "0bcb2e79d8571787f18b7eb036ed3d004908e604",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "require-dev": {
                "phpunit/phpunit": "4.*"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\Inflector\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Common String Manipulations with regard to casing and singular/plural rules.",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "inflection",
                "pluralize",
                "singularize",
                "string"
            ],
            "time": "2014-12-20 21:24:13"
        },
        {
            "name": "doctrine/instantiator",
            "version": "1.0.4",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/instantiator.git",
                "reference": "f976e5de371104877ebc89bd8fecb0019ed9c119"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/instantiator/zipball/f976e5de371104877ebc89bd8fecb0019ed9c119",
                "reference": "f976e5de371104877ebc89bd8fecb0019ed9c119",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3,<8.0-DEV"
            },
            "require-dev": {
                "athletic/athletic": "~0.1.8",
                "ext-pdo": "*",
                "ext-phar": "*",
                "phpunit/phpunit": "~4.0",
                "squizlabs/php_codesniffer": "2.0.*@ALPHA"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Instantiator\\": "src"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Marco Pivetta",
                    "email": "[email protected]",
                    "homepage": "http://ocramius.github.com/"
                }
            ],
            "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
            "homepage": "https://github.com/doctrine/instantiator",
            "keywords": [
                "constructor",
                "instantiate"
            ],
            "time": "2014-10-13 12:58:55"
        },
        {
            "name": "doctrine/lexer",
            "version": "v1.0.1",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/lexer.git",
                "reference": "83893c552fd2045dd78aef794c31e694c37c0b8c"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/lexer/zipball/83893c552fd2045dd78aef794c31e694c37c0b8c",
                "reference": "83893c552fd2045dd78aef794c31e694c37c0b8c",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\Common\\Lexer\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Base library for a lexer that can be used in Top-Down, Recursive Descent Parsers.",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "lexer",
                "parser"
            ],
            "time": "2014-09-09 13:34:57"
        },
        {
            "name": "doctrine/orm",
            "version": "v2.5.0",
            "source": {
                "type": "git",
                "url": "https://github.com/doctrine/doctrine2.git",
                "reference": "aa80c7d2c55a372f5f9f825f5c66dbda53a6e3fe"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/doctrine/doctrine2/zipball/aa80c7d2c55a372f5f9f825f5c66dbda53a6e3fe",
                "reference": "aa80c7d2c55a372f5f9f825f5c66dbda53a6e3fe",
                "shasum": ""
            },
            "require": {
                "doctrine/cache": "~1.4",
                "doctrine/collections": "~1.2",
                "doctrine/common": ">=2.5-dev,<2.6-dev",
                "doctrine/dbal": ">=2.5-dev,<2.6-dev",
                "doctrine/instantiator": "~1.0.1",
                "ext-pdo": "*",
                "php": ">=5.4",
                "symfony/console": "~2.5"
            },
            "require-dev": {
                "phpunit/phpunit": "~4.0",
                "satooshi/php-coveralls": "dev-master",
                "symfony/yaml": "~2.1"
            },
            "suggest": {
                "symfony/yaml": "If you want to use YAML Metadata Mapping Driver"
            },
            "bin": [
                "bin/doctrine",
                "bin/doctrine.php"
            ],
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.6.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Doctrine\\ORM\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Roman Borschel",
                    "email": "[email protected]"
                },
                {
                    "name": "Benjamin Eberlei",
                    "email": "[email protected]"
                },
                {
                    "name": "Guilherme Blanco",
                    "email": "[email protected]"
                },
                {
                    "name": "Jonathan Wage",
                    "email": "[email protected]"
                }
            ],
            "description": "Object-Relational-Mapper for PHP",
            "homepage": "http://www.doctrine-project.org",
            "keywords": [
                "database",
                "orm"
            ],
            "time": "2015-04-02 20:40:18"
        },
        {
            "name": "evolution7/bugsnag-bundle",
            "version": "1.2.0",
            "target-dir": "Evolution7/BugsnagBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/evolution7/Evolution7BugsnagBundle.git",
                "reference": "c148795cf478e0b1b124c5812705294fea3b3ff0"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/evolution7/Evolution7BugsnagBundle/zipball/c148795cf478e0b1b124c5812705294fea3b3ff0",
                "reference": "c148795cf478e0b1b124c5812705294fea3b3ff0",
                "shasum": ""
            },
            "require": {
                "bugsnag/bugsnag": "2.*",
                "php": ">=5.3.3",
                "symfony/symfony": ">=2.2.0"
            },
            "require-dev": {
                "evolution7/qa-tools": "1.*"
            },
            "type": "symfony-bundle",
            "autoload": {
                "psr-0": {
                    "Evolution7\\BugsnagBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "description": "Bugsnag error reporting integration for Symfony2",
            "homepage": "https://github.com/evolution7/Evolution7BugsnagBundle",
            "keywords": [
                "Symfony2",
                "bugsnag",
                "errors",
                "exceptions",
                "logging",
                "tracking"
            ],
            "time": "2015-04-27 23:36:12"
        },
        {
            "name": "friendsofsymfony/user-bundle",
            "version": "dev-master",
            "source": {
                "type": "git",
                "url": "https://github.com/FriendsOfSymfony/FOSUserBundle.git",
                "reference": "92d5624f2a29e74d8fd9d2a94d7ed7998a8c2809"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/FriendsOfSymfony/FOSUserBundle/zipball/92d5624f2a29e74d8fd9d2a94d7ed7998a8c2809",
                "reference": "92d5624f2a29e74d8fd9d2a94d7ed7998a8c2809",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2",
                "symfony/form": "~2.3",
                "symfony/framework-bundle": "~2.3",
                "symfony/security-bundle": "~2.3",
                "symfony/twig-bundle": "~2.3"
            },
            "require-dev": {
                "doctrine/doctrine-bundle": "~1.3",
                "swiftmailer/swiftmailer": "~4.3|~5",
                "symfony/validator": "~2.3",
                "symfony/yaml": "~2.3",
                "willdurand/propel-typehintable-behavior": "~1.0"
            },
            "suggest": {
                "willdurand/propel-typehintable-behavior": "Needed when using the propel implementation"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.0.x-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "FOS\\UserBundle\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Christophe Coevoet",
                    "email": "[email protected]"
                },
                {
                    "name": "FriendsOfSymfony Community",
                    "homepage": "https://github.com/friendsofsymfony/FOSUserBundle/contributors"
                },
                {
                    "name": "Thibault Duplessis",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony FOSUserBundle",
            "homepage": "http://friendsofsymfony.github.com",
            "keywords": [
                "User management"
            ],
            "time": "2015-05-05 15:08:24"
        },
        {
            "name": "gedmo/doctrine-extensions",
            "version": "dev-master",
            "source": {
                "type": "git",
                "url": "https://github.com/Atlantic18/DoctrineExtensions.git",
                "reference": "3940af1099c47dd4bea036616730e8760a3fdba1"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/Atlantic18/DoctrineExtensions/zipball/3940af1099c47dd4bea036616730e8760a3fdba1",
                "reference": "3940af1099c47dd4bea036616730e8760a3fdba1",
                "shasum": ""
            },
            "require": {
                "behat/transliterator": "~1.0",
                "doctrine/common": "~2.4",
                "php": ">=5.3.2"
            },
            "require-dev": {
                "doctrine/common": ">=2.5.0-BETA1",
                "doctrine/mongodb-odm": ">=1.0.0-BETA12",
                "doctrine/orm": ">=2.5.0-RC1",
                "phpunit/phpunit": "~4.4",
                "phpunit/phpunit-mock-objects": "~2.3",
                "symfony/yaml": "~2.6"
            },
            "suggest": {
                "doctrine/mongodb-odm": "to use the extensions with the MongoDB ODM",
                "doctrine/orm": "to use the extensions with the ORM"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.4.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Gedmo\\": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "David Buchmann",
                    "email": "[email protected]"
                },
                {
                    "name": "Gediminas Morkevicius",
                    "email": "[email protected]"
                },
                {
                    "name": "Gustavo Falco",
                    "email": "[email protected]"
                }
            ],
            "description": "Doctrine2 behavioral extensions",
            "homepage": "http://gediminasm.org/",
            "keywords": [
                "Blameable",
                "behaviors",
                "doctrine2",
                "extensions",
                "gedmo",
                "loggable",
                "nestedset",
                "sluggable",
                "sortable",
                "timestampable",
                "translatable",
                "tree",
                "uploadable"
            ],
            "time": "2015-05-01 08:39:37"
        },
        {
            "name": "genemu/form-bundle",
            "version": "v2.2.2",
            "target-dir": "Genemu/Bundle/FormBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/genemu/GenemuFormBundle.git",
                "reference": "9fecbe7a12fba1761228909e843301c4d1a11e7c"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/genemu/GenemuFormBundle/zipball/9fecbe7a12fba1761228909e843301c4d1a11e7c",
                "reference": "9fecbe7a12fba1761228909e843301c4d1a11e7c",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2",
                "symfony/form": "~2.3",
                "symfony/framework-bundle": "~2.3"
            },
            "require-dev": {
                "doctrine/doctrine-bundle": "1.*",
                "doctrine/mongodb-odm-bundle": "*",
                "doctrine/orm": "2.*",
                "propel/propel-bundle": "*",
                "symfony/doctrine-bridge": "~2.3",
                "symfony/finder": "2.*"
            },
            "suggest": {
                "symfony/doctrine-bundle": "In order to use some form types with Doctrine",
                "symfony/finder": "For an image type",
                "symfony/mongodb-odm-bundle": "For MongoDB integration",
                "symfony/twig-bridge": "For integration into Twig templates"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.2-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Genemu\\Bundle\\FormBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Olivier Chauvel",
                    "email": "[email protected]"
                },
                {
                    "name": "Community contributions",
                    "homepage": "https://github.com/genemu/GenemuFormBundle/contributors"
                },
                {
                    "name": "Bilal Amarni",
                    "email": "[email protected]"
                }
            ],
            "description": "Extra form types for your Symfony2 projects",
            "keywords": [
                "extra form",
                "form"
            ],
            "time": "2014-03-23 12:12:05"
        },
        {
            "name": "google/apiclient",
            "version": "1.0.6-beta",
            "source": {
                "type": "git",
                "url": "https://github.com/google/google-api-php-client.git",
                "reference": "a41a9dc0662e36420030eaab802dbb1f85459479"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/google/google-api-php-client/zipball/a41a9dc0662e36420030eaab802dbb1f85459479",
                "reference": "a41a9dc0662e36420030eaab802dbb1f85459479",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2.1"
            },
            "require-dev": {
                "phpunit/phpunit": "3.7.*"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev"
                }
            },
            "autoload": {
                "classmap": [
                    "src/"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "include-path": [
                "src/"
            ],
            "license": [
                "Apache-2.0"
            ],
            "description": "Client library for Google APIs",
            "homepage": "http://developers.google.com/api-client-library/php",
            "keywords": [
                "google"
            ],
            "time": "2014-09-30 19:33:59"
        },
        {
            "name": "imagine/imagine",
            "version": "0.6.2",
            "source": {
                "type": "git",
                "url": "https://github.com/avalanche123/Imagine.git",
                "reference": "83ca8babede0e54f935ec09d55a726bf4b0a3f7c"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/avalanche123/Imagine/zipball/83ca8babede0e54f935ec09d55a726bf4b0a3f7c",
                "reference": "83ca8babede0e54f935ec09d55a726bf4b0a3f7c",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "require-dev": {
                "sami/sami": "dev-master"
            },
            "suggest": {
                "ext-gd": "to use the GD implementation",
                "ext-gmagick": "to use the Gmagick implementation",
                "ext-imagick": "to use the Imagick implementation"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-develop": "0.7-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Imagine": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Bulat Shakirzyanov",
                    "email": "[email protected]",
                    "homepage": "http://avalanche123.com"
                }
            ],
            "description": "Image processing for PHP 5.3",
            "homepage": "http://imagine.readthedocs.org/",
            "keywords": [
                "drawing",
                "graphics",
                "image manipulation",
                "image processing"
            ],
            "time": "2014-11-11 11:36:02"
        },
        {
            "name": "jdorn/sql-formatter",
            "version": "v1.2.17",
            "source": {
                "type": "git",
                "url": "https://github.com/jdorn/sql-formatter.git",
                "reference": "64990d96e0959dff8e059dfcdc1af130728d92bc"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/jdorn/sql-formatter/zipball/64990d96e0959dff8e059dfcdc1af130728d92bc",
                "reference": "64990d96e0959dff8e059dfcdc1af130728d92bc",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2.4"
            },
            "require-dev": {
                "phpunit/phpunit": "3.7.*"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.3.x-dev"
                }
            },
            "autoload": {
                "classmap": [
                    "lib"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Jeremy Dorn",
                    "email": "[email protected]",
                    "homepage": "http://jeremydorn.com/"
                }
            ],
            "description": "a PHP SQL highlighting library",
            "homepage": "https://github.com/jdorn/sql-formatter/",
            "keywords": [
                "highlight",
                "sql"
            ],
            "time": "2014-01-12 16:20:24"
        },
        {
            "name": "jms/aop-bundle",
            "version": "1.0.1",
            "target-dir": "JMS/AopBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSAopBundle.git",
                "reference": "93f41ab85ed409430bc3bab2e0b7c7677f152aa8"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSAopBundle/zipball/93f41ab85ed409430bc3bab2e0b7c7677f152aa8",
                "reference": "93f41ab85ed409430bc3bab2e0b7c7677f152aa8",
                "shasum": ""
            },
            "require": {
                "jms/cg": "1.*",
                "symfony/framework-bundle": "2.*"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.1.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\AopBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Adds AOP capabilities to Symfony2",
            "keywords": [
                "annotations",
                "aop"
            ],
            "time": "2013-07-29 09:34:26"
        },
        {
            "name": "jms/cg",
            "version": "1.0.0",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/cg-library.git",
                "reference": "ce8ef43dd6bfe6ce54e5e9844ab71be2343bf2fc"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/cg-library/zipball/ce8ef43dd6bfe6ce54e5e9844ab71be2343bf2fc",
                "reference": "ce8ef43dd6bfe6ce54e5e9844ab71be2343bf2fc",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.0"
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "CG\\": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Toolset for generating PHP code",
            "keywords": [
                "code generation"
            ],
            "time": "2012-01-02 20:40:52"
        },
        {
            "name": "jms/di-extra-bundle",
            "version": "dev-master",
            "target-dir": "JMS/DiExtraBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSDiExtraBundle.git",
                "reference": "36f8b06e34e55582be59c810eac855396fc57221"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSDiExtraBundle/zipball/36f8b06e34e55582be59c810eac855396fc57221",
                "reference": "36f8b06e34e55582be59c810eac855396fc57221",
                "shasum": ""
            },
            "require": {
                "jms/aop-bundle": ">=1.0.0,<1.2-dev",
                "jms/metadata": "1.*",
                "symfony/finder": "~2.1",
                "symfony/framework-bundle": "~2.1",
                "symfony/process": "~2.1"
            },
            "require-dev": {
                "doctrine/doctrine-bundle": "*",
                "doctrine/orm": "*",
                "jms/security-extra-bundle": "1.*",
                "phpcollection/phpcollection": ">=0.1,<0.3-dev",
                "sensio/framework-extra-bundle": "*",
                "symfony/browser-kit": "*",
                "symfony/class-loader": "*",
                "symfony/form": "*",
                "symfony/security-bundle": "*",
                "symfony/twig-bundle": "*",
                "symfony/validator": "*",
                "symfony/yaml": "*"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.5-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\DiExtraBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache"
            ],
            "authors": [
                {
                    "name": "Johannes M. Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Allows to configure dependency injection using annotations",
            "homepage": "http://jmsyst.com/bundles/JMSDiExtraBundle",
            "keywords": [
                "annotations",
                "dependency injection"
            ],
            "time": "2015-05-21 14:28:38"
        },
        {
            "name": "jms/i18n-routing-bundle",
            "version": "dev-master",
            "target-dir": "JMS/I18nRoutingBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSI18nRoutingBundle.git",
                "reference": "eda6c5ff06c9100e5cad143b8a74224e0038a97c"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSI18nRoutingBundle/zipball/eda6c5ff06c9100e5cad143b8a74224e0038a97c",
                "reference": "eda6c5ff06c9100e5cad143b8a74224e0038a97c",
                "shasum": ""
            },
            "require": {
                "jms/translation-bundle": "~1.0",
                "symfony/framework-bundle": "~2.1"
            },
            "require-dev": {
                "jms/di-extra-bundle": "*",
                "sensio/framework-extra-bundle": "<2.1.5",
                "symfony/browser-kit": "<2.1.5",
                "symfony/class-loader": "<2.1.5",
                "symfony/css-selector": "<2.1.5",
                "symfony/finder": "<2.1.5",
                "symfony/form": "<2.1.5",
                "symfony/framework-bundle": "<2.1.5",
                "symfony/http-foundation": "<2.1.5",
                "symfony/http-kernel": "<2.1.5",
                "symfony/process": "<2.1.5",
                "symfony/routing": "<2.1.5",
                "symfony/twig-bundle": "<2.1.5",
                "symfony/validator": "<2.1.5",
                "symfony/yaml": "<2.1.5"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.1-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\I18nRoutingBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes M. Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "This bundle allows you to create i18n routes.",
            "homepage": "http://jmsyst.com/bundles/JMSI18nRoutingBundle",
            "keywords": [
                "multilanguage",
                "routing",
                "translation"
            ],
            "time": "2015-02-20 16:41:04"
        },
        {
            "name": "jms/metadata",
            "version": "1.5.1",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/metadata.git",
                "reference": "22b72455559a25777cfd28c4ffda81ff7639f353"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/metadata/zipball/22b72455559a25777cfd28c4ffda81ff7639f353",
                "reference": "22b72455559a25777cfd28c4ffda81ff7639f353",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.0"
            },
            "require-dev": {
                "doctrine/cache": "~1.0"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.5.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Metadata\\": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Class/method/property metadata management in PHP",
            "keywords": [
                "annotations",
                "metadata",
                "xml",
                "yaml"
            ],
            "time": "2014-07-12 07:13:19"
        },
        {
            "name": "jms/parser-lib",
            "version": "1.0.0",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/parser-lib.git",
                "reference": "c509473bc1b4866415627af0e1c6cc8ac97fa51d"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/parser-lib/zipball/c509473bc1b4866415627af0e1c6cc8ac97fa51d",
                "reference": "c509473bc1b4866415627af0e1c6cc8ac97fa51d",
                "shasum": ""
            },
            "require": {
                "phpoption/phpoption": ">=0.9,<2.0-dev"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "description": "A library for easily creating recursive-descent parsers.",
            "time": "2012-11-18 18:08:43"
        },
        {
            "name": "jms/security-extra-bundle",
            "version": "dev-master",
            "target-dir": "JMS/SecurityExtraBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSSecurityExtraBundle.git",
                "reference": "59b777ebaa37803a75803982ddab18c08a47e48f"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSSecurityExtraBundle/zipball/59b777ebaa37803a75803982ddab18c08a47e48f",
                "reference": "59b777ebaa37803a75803982ddab18c08a47e48f",
                "shasum": ""
            },
            "require": {
                "jms/aop-bundle": "~1.0",
                "jms/di-extra-bundle": "~1.3",
                "jms/metadata": "~1.0",
                "jms/parser-lib": "~1.0",
                "symfony/framework-bundle": "~2.1",
                "symfony/security-bundle": "*"
            },
            "require-dev": {
                "doctrine/doctrine-bundle": "*",
                "doctrine/orm": "*",
                "sensio/framework-extra-bundle": "*",
                "symfony/browser-kit": "*",
                "symfony/class-loader": "*",
                "symfony/css-selector": "*",
                "symfony/finder": "*",
                "symfony/form": "*",
                "symfony/process": "*",
                "symfony/twig-bundle": "*",
                "symfony/validator": "*",
                "symfony/yaml": "*"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.5-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\SecurityExtraBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes M. Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Enhances the Symfony2 Security Component by adding several new features",
            "homepage": "http://jmsyst.com/bundles/JMSSecurityExtraBundle",
            "keywords": [
                "annotations",
                "authorization",
                "expression",
                "secure",
                "security"
            ],
            "time": "2014-08-20 16:22:51"
        },
        {
            "name": "jms/serializer",
            "version": "0.16.0",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/serializer.git",
                "reference": "c8a171357ca92b6706e395c757f334902d430ea9"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/serializer/zipball/c8a171357ca92b6706e395c757f334902d430ea9",
                "reference": "c8a171357ca92b6706e395c757f334902d430ea9",
                "shasum": ""
            },
            "require": {
                "doctrine/annotations": "1.*",
                "jms/metadata": "~1.1",
                "jms/parser-lib": "1.*",
                "php": ">=5.3.2",
                "phpcollection/phpcollection": "~0.1"
            },
            "require-dev": {
                "doctrine/orm": "~2.1",
                "doctrine/phpcr-odm": "~1.0.1",
                "jackalope/jackalope-doctrine-dbal": "1.0.*",
                "propel/propel1": "~1.7",
                "symfony/filesystem": "2.*",
                "symfony/form": "~2.1",
                "symfony/translation": "~2.0",
                "symfony/validator": "~2.0",
                "symfony/yaml": "2.*",
                "twig/twig": ">=1.8,<2.0-dev"
            },
            "suggest": {
                "symfony/yaml": "Required if you'd like to serialize data to YAML format."
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "0.15-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\Serializer": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Library for (de-)serializing data of any complexity; supports XML, JSON, and YAML.",
            "homepage": "http://jmsyst.com/libs/serializer",
            "keywords": [
                "deserialization",
                "jaxb",
                "json",
                "serialization",
                "xml"
            ],
            "time": "2014-03-18 08:39:00"
        },
        {
            "name": "jms/serializer-bundle",
            "version": "dev-master",
            "target-dir": "JMS/SerializerBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSSerializerBundle.git",
                "reference": "c49628cfc8b8ce7404665b4e6528487d780e7d68"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSSerializerBundle/zipball/c49628cfc8b8ce7404665b4e6528487d780e7d68",
                "reference": "c49628cfc8b8ce7404665b4e6528487d780e7d68",
                "shasum": ""
            },
            "require": {
                "jms/serializer": "~0.12",
                "php": ">=5.3.2",
                "symfony/framework-bundle": "~2.1"
            },
            "require-dev": {
                "doctrine/doctrine-bundle": "*",
                "doctrine/orm": "*",
                "symfony/browser-kit": "*",
                "symfony/class-loader": "*",
                "symfony/css-selector": "*",
                "symfony/finder": "*",
                "symfony/form": "*",
                "symfony/process": "*",
                "symfony/stopwatch": "*",
                "symfony/twig-bundle": "*",
                "symfony/validator": "*",
                "symfony/yaml": "*"
            },
            "suggest": {
                "jms/di-extra-bundle": "Required to get lazy loading (de)serialization visitors, ~1.3"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "0.13-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\SerializerBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes M. Schmitt",
                    "email": "[email protected]"
                }
            ],
            "description": "Allows you to easily serialize, and deserialize data of any complexity",
            "homepage": "http://jmsyst.com/bundles/JMSSerializerBundle",
            "keywords": [
                "deserialization",
                "jaxb",
                "json",
                "serialization",
                "xml"
            ],
            "time": "2015-03-24 16:48:01"
        },
        {
            "name": "jms/translation-bundle",
            "version": "1.1.0",
            "target-dir": "JMS/TranslationBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/JMSTranslationBundle.git",
                "reference": "6f03035a38badaf8c48767c7664c3196df1eebdf"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/JMSTranslationBundle/zipball/6f03035a38badaf8c48767c7664c3196df1eebdf",
                "reference": "6f03035a38badaf8c48767c7664c3196df1eebdf",
                "shasum": ""
            },
            "require": {
                "nikic/php-parser": "0.9.1",
                "symfony/console": "*",
                "symfony/framework-bundle": "~2.1"
            },
            "conflict": {
                "twig/twig": "1.10.2"
            },
            "require-dev": {
                "jms/di-extra-bundle": ">=1.1",
                "sensio/framework-extra-bundle": "*",
                "symfony/browser-kit": "*",
                "symfony/class-loader": "*",
                "symfony/css-selector": "*",
                "symfony/finder": "*",
                "symfony/form": "*",
                "symfony/process": "*",
                "symfony/security": "*",
                "symfony/twig-bundle": "*",
                "symfony/validator": "*",
                "symfony/yaml": "*"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.1-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "JMS\\TranslationBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Puts the Symfony2 Translation Component on steroids",
            "homepage": "http://jmsyst.com/bundles/JMSTranslationBundle",
            "keywords": [
                "extract",
                "extraction",
                "i18n",
                "interface",
                "multilanguage",
                "translation",
                "ui",
                "webinterface"
            ],
            "time": "2013-06-08 14:08:19"
        },
        {
            "name": "knplabs/doctrine-behaviors",
            "version": "dev-master",
            "source": {
                "type": "git",
                "url": "https://github.com/KnpLabs/DoctrineBehaviors.git",
                "reference": "08669a8231a9be27c5cdb7268d02ff278b5af923"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/KnpLabs/DoctrineBehaviors/zipball/08669a8231a9be27c5cdb7268d02ff278b5af923",
                "reference": "08669a8231a9be27c5cdb7268d02ff278b5af923",
                "shasum": ""
            },
            "require": {
                "behat/transliterator": "~1.0",
                "doctrine/common": ">=2.2",
                "php": ">=5.4"
            },
            "require-dev": {
                "doctrine/orm": ">=2.2",
                "ext-pdo_mysql": "*",
                "ext-pdo_pgsql": "*",
                "ext-pdo_sqlite": "*",
                "hexmedia/yaml-linter": "~0.1",
                "jakub-onderka/php-parallel-lint": "~0.8",
                "phpunit/phpunit": "~3.7"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.1.x-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Knp\\DoctrineBehaviors\\": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Knplabs",
                    "homepage": "http://knplabs.com"
                }
            ],
            "description": "Doctrine2 behavior traits",
            "homepage": "http://knplabs.com",
            "keywords": [
                "Blameable",
                "behaviors",
                "doctrine2",
                "filterable",
                "softdeletable",
                "timestampable",
                "translatable",
                "tree"
            ],
            "time": "2015-05-26 02:48:37"
        },
        {
            "name": "knplabs/knp-components",
            "version": "1.3.1",
            "source": {
                "type": "git",
                "url": "https://github.com/KnpLabs/knp-components.git",
                "reference": "6d091c2f16eec2769db38f38e08c7bd5847ce072"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/KnpLabs/knp-components/zipball/6d091c2f16eec2769db38f38e08c7bd5847ce072",
                "reference": "6d091c2f16eec2769db38f38e08c7bd5847ce072",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2"
            },
            "require-dev": {
                "doctrine/mongodb-odm": "~1.0@beta",
                "doctrine/orm": "~2.4",
                "phpunit/phpunit": "~4.2",
                "ruflin/elastica": "~1.0",
                "symfony/event-dispatcher": "~2.5"
            },
            "suggest": {
                "doctrine/common": "to allow usage pagination with Doctrine ArrayCollection",
                "doctrine/mongodb-odm": "to allow usage pagination with Doctrine ODM MongoDB",
                "doctrine/orm": "to allow usage pagination with Doctrine ORM",
                "propel/propel1": "to allow usage pagination with Propel ORM",
                "ruflin/Elastica": "to allow usage pagination with ElasticSearch Client",
                "solarium/solarium": "to allow usage pagination with Solarium Client"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.2.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Knp\\Component": "src"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "KnpLabs Team",
                    "homepage": "http://knplabs.com"
                },
                {
                    "name": "Symfony Community",
                    "homepage": "http://github.com/KnpLabs/knp-components/contributors"
                }
            ],
            "description": "Knplabs component library",
            "homepage": "http://github.com/KnpLabs/knp-components",
            "keywords": [
                "components",
                "knp",
                "knplabs",
                "pager",
                "paginator"
            ],
            "time": "2014-10-06 10:38:10"
        },
        {
            "name": "knplabs/knp-paginator-bundle",
            "version": "2.4.1",
            "target-dir": "Knp/Bundle/PaginatorBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/KnpLabs/KnpPaginatorBundle.git",
                "reference": "701dffe02dbe4aa8784d3d9e5343985318ef5e2c"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/KnpLabs/KnpPaginatorBundle/zipball/701dffe02dbe4aa8784d3d9e5343985318ef5e2c",
                "reference": "701dffe02dbe4aa8784d3d9e5343985318ef5e2c",
                "shasum": ""
            },
            "require": {
                "knplabs/knp-components": "~1.2",
                "php": ">=5.3.3",
                "symfony/framework-bundle": "~2.0",
                "twig/twig": "~1.5"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.4.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Knp\\Bundle\\PaginatorBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "KnpLabs Team",
                    "homepage": "http://knplabs.com"
                },
                {
                    "name": "Symfony2 Community",
                    "homepage": "http://github.com/KnpLabs/KnpPaginatorBundle/contributors"
                }
            ],
            "description": "Paginator bundle for Symfony2 to automate pagination and simplify sorting and other features",
            "homepage": "http://github.com/KnpLabs/KnpPaginatorBundle",
            "keywords": [
                "Symfony2",
                "bundle",
                "knp",
                "knplabs",
                "pager",
                "pagination",
                "paginator"
            ],
            "time": "2014-09-15 15:49:24"
        },
        {
            "name": "kriswallsmith/assetic",
            "version": "v1.2.1",
            "source": {
                "type": "git",
                "url": "https://github.com/kriswallsmith/assetic.git",
                "reference": "b20efe38845d20458702f97f3ff625d80805897b"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/kriswallsmith/assetic/zipball/b20efe38845d20458702f97f3ff625d80805897b",
                "reference": "b20efe38845d20458702f97f3ff625d80805897b",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.1",
                "symfony/process": "~2.1"
            },
            "require-dev": {
                "cssmin/cssmin": "*",
                "joliclic/javascript-packer": "*",
                "kamicane/packager": "*",
                "leafo/lessphp": "*",
                "leafo/scssphp": "*",
                "leafo/scssphp-compass": "*",
                "mrclay/minify": "*",
                "patchwork/jsqueeze": "~1.0",
                "phpunit/phpunit": "~4",
                "psr/log": "~1.0",
                "ptachoire/cssembed": "*",
                "twig/twig": "~1.6"
            },
            "suggest": {
                "leafo/lessphp": "Assetic provides the integration with the lessphp LESS compiler",
                "leafo/scssphp": "Assetic provides the integration with the scssphp SCSS compiler",
                "leafo/scssphp-compass": "Assetic provides the integration with the SCSS compass plugin",
                "patchwork/jsqueeze": "Assetic provides the integration with the JSqueeze JavaScript compressor",
                "ptachoire/cssembed": "Assetic provides the integration with phpcssembed to embed data uris",
                "twig/twig": "Assetic provides the integration with the Twig templating engine"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.2-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Assetic": "src/"
                },
                "files": [
                    "src/functions.php"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Kris Wallsmith",
                    "email": "[email protected]",
                    "homepage": "http://kriswallsmith.net/"
                }
            ],
            "description": "Asset Management for PHP",
            "homepage": "https://github.com/kriswallsmith/assetic",
            "keywords": [
                "assets",
                "compression",
                "minification"
            ],
            "time": "2014-12-12 05:04:05"
        },
        {
            "name": "lexik/form-filter-bundle",
            "version": "v3.0.5",
            "target-dir": "Lexik/Bundle/FormFilterBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/lexik/LexikFormFilterBundle.git",
                "reference": "cd74e78fab839cdb00998359f00e7ee980fdba80"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/lexik/LexikFormFilterBundle/zipball/cd74e78fab839cdb00998359f00e7ee980fdba80",
                "reference": "cd74e78fab839cdb00998359f00e7ee980fdba80",
                "shasum": ""
            },
            "require": {
                "doctrine/orm": "~2.2",
                "php": ">=5.3.2",
                "symfony/form": "~2.3",
                "symfony/framework-bundle": "~2.3"
            },
            "require-dev": {
                "phpunit/phpunit": "~3.7"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "3.x.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Lexik\\Bundle\\FormFilterBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Dev Lexik",
                    "email": "[email protected]"
                },
                {
                    "name": "Cedric Girard",
                    "email": "[email protected]"
                }
            ],
            "description": "This bundle aim to provide classes to build some form filters and then build a doctrine query from this form filter.",
            "homepage": "https://github.com/lexik/LexikFormFilterBundle",
            "keywords": [
                "Symfony2",
                "bundle",
                "doctrine",
                "filter",
                "form"
            ],
            "time": "2015-05-11 15:04:07"
        },
        {
            "name": "lexik/translation-bundle",
            "version": "dev-master",
            "target-dir": "Lexik/Bundle/TranslationBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/lexik/LexikTranslationBundle.git",
                "reference": "8fdd7f1506c819da8d2ed07c30115e9cb6bad8cd"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/lexik/LexikTranslationBundle/zipball/8fdd7f1506c819da8d2ed07c30115e9cb6bad8cd",
                "reference": "8fdd7f1506c819da8d2ed07c30115e9cb6bad8cd",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2",
                "symfony/framework-bundle": "~2.3"
            },
            "require-dev": {
                "doctrine/data-fixtures": "1.0.*",
                "doctrine/doctrine-bundle": "~1.3",
                "doctrine/mongodb-odm": "dev-master",
                "doctrine/mongodb-odm-bundle": "dev-master",
                "doctrine/orm": "2.4.*",
                "phpunit/phpunit": "~4.3",
                "propel/propel-bundle": "~1.2"
            },
            "suggest": {
                "doctrine/mongodb-odm": "1.0.*@dev",
                "doctrine/orm": ">=2.4",
                "propel/propel-bundle": "~1.2"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.x.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Lexik\\Bundle\\TranslationBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Dev Lexik",
                    "email": "[email protected]"
                },
                {
                    "name": "Cedric Girard",
                    "email": "[email protected]"
                }
            ],
            "description": "This bundle allow to import translation files content into the database and provide a GUI to edit translations.",
            "homepage": "https://github.com/lexik/LexikTranslationBundle",
            "keywords": [
                "Symfony2",
                "bundle",
                "i18n",
                "translation"
            ],
            "time": "2015-05-22 07:00:20"
        },
        {
            "name": "liip/imagine-bundle",
            "version": "1.2.6",
            "target-dir": "Liip/ImagineBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/liip/LiipImagineBundle.git",
                "reference": "e24256aa688b1afc9edfaae86f82c80d9e471436"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/liip/LiipImagineBundle/zipball/e24256aa688b1afc9edfaae86f82c80d9e471436",
                "reference": "e24256aa688b1afc9edfaae86f82c80d9e471436",
                "shasum": ""
            },
            "require": {
                "imagine/imagine": "~0.5,<0.7",
                "php": ">=5.3.2",
                "symfony/filesystem": "~2.3",
                "symfony/finder": "~2.3",
                "symfony/framework-bundle": "~2.3",
                "symfony/options-resolver": "~2.3"
            },
            "require-dev": {
                "amazonwebservices/aws-sdk-for-php": "~1.0",
                "aws/aws-sdk-php": "~2.4",
                "doctrine/cache": "~1.1",
                "doctrine/mongodb-odm": "1.0.*",
                "doctrine/orm": "~2.3",
                "ext-gd": "*",
                "phpunit/phpunit": "~4.3",
                "psr/log": "~1.0",
                "symfony/browser-kit": "~2.3",
                "symfony/console": "~2.3",
                "symfony/form": "~2.3",
                "symfony/yaml": "~2.3",
                "twig/twig": "~1.0"
            },
            "suggest": {
                "amazonwebservices/aws-sdk-for-php": "Add it if you'd like to use aws v1 resolver",
                "aws/aws-sdk-php": "Add it if you'd like to use aws v2 resolver",
                "monolog/monolog": "If you'd want to write logs",
                "twig/twig": "If you'd want to use some handy twig filters"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.0.x-dev",
                    "dev-0.x": "0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Liip\\ImagineBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Liip and other contributors",
                    "homepage": "https://github.com/liip/LiipImagineBundle/contributors"
                }
            ],
            "description": "This Bundle assists in imagine manipulation using the imagine library",
            "homepage": "http://liip.ch",
            "keywords": [
                "image",
                "imagine"
            ],
            "time": "2015-04-24 13:41:22"
        },
        {
            "name": "liuggio/ExcelBundle",
            "version": "v2.0.2",
            "target-dir": "Liuggio/ExcelBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/liuggio/ExcelBundle.git",
                "reference": "33ce101e5fb76786ea05da350ab394b596d7ee52"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/liuggio/ExcelBundle/zipball/33ce101e5fb76786ea05da350ab394b596d7ee52",
                "reference": "33ce101e5fb76786ea05da350ab394b596d7ee52",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2",
                "phpoffice/phpexcel": "~1.8.0",
                "symfony/framework-bundle": "~2.6"
            },
            "require-dev": {
                "phpunit/phpunit": "~4.6",
                "sensio/framework-extra-bundle": "~2.3",
                "symfony/browser-kit": "~2.6",
                "symfony/class-loader": "~2.6",
                "symfony/finder": "~2.6",
                "symfony/form": "~2.6",
                "symfony/validator": "~2.6"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Liuggio\\ExcelBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "ExcelBundle Contributors",
                    "homepage": "https://github.com/liuggio/ExcelBundle#contributors"
                },
                {
                    "name": "Giulio De Donato",
                    "email": "[email protected]"
                }
            ],
            "description": "This is a Symfony2 Bundle helps you to read and write Excel files (including pdf, xlsx, odt), thanks to the PHPExcel library",
            "homepage": "http://www.welcometothebundle.com",
            "keywords": [
                "Symfony2",
                "bundle",
                "excel",
                "xls"
            ],
            "time": "2015-05-15 09:50:11"
        },
        {
            "name": "mandrill/mandrill",
            "version": "1.0.54",
            "source": {
                "type": "git",
                "url": "https://bitbucket.org/mailchimp/mandrill-api-php.git",
                "reference": "9f336b08ea148c80db3b694f3dc737cd4f414e19"
            },
            "dist": {
                "type": "zip",
                "url": "https://bitbucket.org/mailchimp/mandrill-api-php/get/9f336b08ea148c80db3b694f3dc737cd4f414e19.zip",
                "reference": "9f336b08ea148c80db3b694f3dc737cd4f414e19",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2.0"
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "Mandrill": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache-2.0"
            ],
            "authors": [
                {
                    "name": "Mandrill Devs",
                    "email": "[email protected]",
                    "homepage": "http://mandrill.com",
                    "role": "Developer"
                }
            ],
            "description": "API client library for the Mandrill email as a service platform",
            "homepage": "https://bitbucket.org/mailchimp/mandrill-api-php",
            "keywords": [
                "api",
                "email"
            ],
            "time": "2014-10-16 21:08:20"
        },
        {
            "name": "monolog/monolog",
            "version": "1.13.1",
            "source": {
                "type": "git",
                "url": "https://github.com/Seldaek/monolog.git",
                "reference": "c31a2c4e8db5da8b46c74cf275d7f109c0f249ac"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/c31a2c4e8db5da8b46c74cf275d7f109c0f249ac",
                "reference": "c31a2c4e8db5da8b46c74cf275d7f109c0f249ac",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.0",
                "psr/log": "~1.0"
            },
            "provide": {
                "psr/log-implementation": "1.0.0"
            },
            "require-dev": {
                "aws/aws-sdk-php": "~2.4, >2.4.8",
                "doctrine/couchdb": "~1.0@dev",
                "graylog2/gelf-php": "~1.0",
                "phpunit/phpunit": "~4.0",
                "raven/raven": "~0.5",
                "ruflin/elastica": "0.90.*",
                "swiftmailer/swiftmailer": "~5.3",
                "videlalvaro/php-amqplib": "~2.4"
            },
            "suggest": {
                "aws/aws-sdk-php": "Allow sending log messages to AWS services like DynamoDB",
                "doctrine/couchdb": "Allow sending log messages to a CouchDB server",
                "ext-amqp": "Allow sending log messages to an AMQP server (1.0+ required)",
                "ext-mongo": "Allow sending log messages to a MongoDB server",
                "graylog2/gelf-php": "Allow sending log messages to a GrayLog2 server",
                "raven/raven": "Allow sending log messages to a Sentry server",
                "rollbar/rollbar": "Allow sending log messages to Rollbar",
                "ruflin/elastica": "Allow sending log messages to an Elastic Search server",
                "videlalvaro/php-amqplib": "Allow sending log messages to an AMQP server using php-amqplib"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.13.x-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Monolog\\": "src/Monolog"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Jordi Boggiano",
                    "email": "[email protected]",
                    "homepage": "http://seld.be"
                }
            ],
            "description": "Sends your logs to files, sockets, inboxes, databases and various web services",
            "homepage": "http://github.com/Seldaek/monolog",
            "keywords": [
                "log",
                "logging",
                "psr-3"
            ],
            "time": "2015-03-09 09:58:04"
        },
        {
            "name": "nikic/php-parser",
            "version": "v0.9.1",
            "source": {
                "type": "git",
                "url": "https://github.com/nikic/PHP-Parser.git",
                "reference": "b1cc9ce676b4350b23d0fafc8244d08eee2fe287"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/b1cc9ce676b4350b23d0fafc8244d08eee2fe287",
                "reference": "b1cc9ce676b4350b23d0fafc8244d08eee2fe287",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2"
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "PHPParser": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "BSD"
            ],
            "authors": [
                {
                    "name": "Nikita Popov"
                }
            ],
            "description": "A PHP parser written in PHP",
            "keywords": [
                "parser",
                "php"
            ],
            "time": "2012-04-23 22:52:11"
        },
        {
            "name": "phpcollection/phpcollection",
            "version": "0.4.0",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/php-collection.git",
                "reference": "b8bf55a0a929ca43b01232b36719f176f86c7e83"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/php-collection/zipball/b8bf55a0a929ca43b01232b36719f176f86c7e83",
                "reference": "b8bf55a0a929ca43b01232b36719f176f86c7e83",
                "shasum": ""
            },
            "require": {
                "phpoption/phpoption": "1.*"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "0.3-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "PhpCollection": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "General-Purpose Collection Library for PHP",
            "keywords": [
                "collection",
                "list",
                "map",
                "sequence",
                "set"
            ],
            "time": "2014-03-11 13:46:42"
        },
        {
            "name": "phpoffice/phpexcel",
            "version": "1.8.1",
            "source": {
                "type": "git",
                "url": "https://github.com/PHPOffice/PHPExcel.git",
                "reference": "372c7cbb695a6f6f1e62649381aeaa37e7e70b32"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/PHPOffice/PHPExcel/zipball/372c7cbb695a6f6f1e62649381aeaa37e7e70b32",
                "reference": "372c7cbb695a6f6f1e62649381aeaa37e7e70b32",
                "shasum": ""
            },
            "require": {
                "ext-xml": "*",
                "ext-xmlwriter": "*",
                "php": ">=5.2.0"
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "PHPExcel": "Classes/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "LGPL"
            ],
            "authors": [
                {
                    "name": "Maarten Balliauw",
                    "homepage": "http://blog.maartenballiauw.be"
                },
                {
                    "name": "Mark Baker"
                },
                {
                    "name": "Franck Lefevre",
                    "homepage": "http://blog.rootslabs.net"
                },
                {
                    "name": "Erik Tilt"
                }
            ],
            "description": "PHPExcel - OpenXML - Read, Create and Write Spreadsheet documents in PHP - Spreadsheet engine",
            "homepage": "http://phpexcel.codeplex.com",
            "keywords": [
                "OpenXML",
                "excel",
                "php",
                "spreadsheet",
                "xls",
                "xlsx"
            ],
            "time": "2015-05-01 07:00:55"
        },
        {
            "name": "phpoption/phpoption",
            "version": "1.4.0",
            "source": {
                "type": "git",
                "url": "https://github.com/schmittjoh/php-option.git",
                "reference": "5d099bcf0393908bf4ad69cc47dafb785d51f7f5"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/schmittjoh/php-option/zipball/5d099bcf0393908bf4ad69cc47dafb785d51f7f5",
                "reference": "5d099bcf0393908bf4ad69cc47dafb785d51f7f5",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.0"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.3-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "PhpOption\\": "src/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "Apache2"
            ],
            "authors": [
                {
                    "name": "Johannes Schmitt",
                    "email": "[email protected]",
                    "homepage": "https://github.com/schmittjoh",
                    "role": "Developer of wrapped JMSSerializerBundle"
                }
            ],
            "description": "Option Type for PHP",
            "keywords": [
                "language",
                "option",
                "php",
                "type"
            ],
            "time": "2014-01-09 22:37:17"
        },
        {
            "name": "psr/log",
            "version": "1.0.0",
            "source": {
                "type": "git",
                "url": "https://github.com/php-fig/log.git",
                "reference": "fe0936ee26643249e916849d48e3a51d5f5e278b"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/php-fig/log/zipball/fe0936ee26643249e916849d48e3a51d5f5e278b",
                "reference": "fe0936ee26643249e916849d48e3a51d5f5e278b",
                "shasum": ""
            },
            "type": "library",
            "autoload": {
                "psr-0": {
                    "Psr\\Log\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "PHP-FIG",
                    "homepage": "http://www.php-fig.org/"
                }
            ],
            "description": "Common interface for logging libraries",
            "keywords": [
                "log",
                "psr",
                "psr-3"
            ],
            "time": "2012-12-21 11:40:51"
        },
        {
            "name": "sensio/distribution-bundle",
            "version": "v3.0.24",
            "target-dir": "Sensio/Bundle/DistributionBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/sensiolabs/SensioDistributionBundle.git",
                "reference": "79b820aee1f1daeb2717fa9471ee19275cc1d638"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/sensiolabs/SensioDistributionBundle/zipball/79b820aee1f1daeb2717fa9471ee19275cc1d638",
                "reference": "79b820aee1f1daeb2717fa9471ee19275cc1d638",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.3",
                "sensiolabs/security-checker": "~2.0",
                "symfony/class-loader": "~2.2",
                "symfony/framework-bundle": "~2.3",
                "symfony/process": "~2.2"
            },
            "require-dev": {
                "symfony/form": "~2.2",
                "symfony/validator": "~2.2",
                "symfony/yaml": "~2.2"
            },
            "suggest": {
                "symfony/form": "If you want to use the configurator",
                "symfony/validator": "If you want to use the configurator",
                "symfony/yaml": "If you want to use  the configurator"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "3.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Sensio\\Bundle\\DistributionBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Base bundle for Symfony Distributions",
            "keywords": [
                "configuration",
                "distribution"
            ],
            "time": "2015-05-16 12:57:08"
        },
        {
            "name": "sensio/framework-extra-bundle",
            "version": "v3.0.7",
            "target-dir": "Sensio/Bundle/FrameworkExtraBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/sensiolabs/SensioFrameworkExtraBundle.git",
                "reference": "5c37623576ea9e841b87dc0d85414d98fa6f7abb"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/sensiolabs/SensioFrameworkExtraBundle/zipball/5c37623576ea9e841b87dc0d85414d98fa6f7abb",
                "reference": "5c37623576ea9e841b87dc0d85414d98fa6f7abb",
                "shasum": ""
            },
            "require": {
                "doctrine/common": "~2.2",
                "symfony/framework-bundle": "~2.3"
            },
            "require-dev": {
                "symfony/expression-language": "~2.4",
                "symfony/security-bundle": "~2.4"
            },
            "suggest": {
                "symfony/expression-language": "",
                "symfony/security-bundle": ""
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "3.0.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Sensio\\Bundle\\FrameworkExtraBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "This bundle provides a way to configure your controllers with annotations",
            "keywords": [
                "annotations",
                "controllers"
            ],
            "time": "2015-04-02 12:28:58"
        },
        {
            "name": "sensiolabs/security-checker",
            "version": "v2.0.3",
            "source": {
                "type": "git",
                "url": "https://github.com/sensiolabs/security-checker.git",
                "reference": "cde03c48d490d805ef1349e5108f8b3085981ead"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/sensiolabs/security-checker/zipball/cde03c48d490d805ef1349e5108f8b3085981ead",
                "reference": "cde03c48d490d805ef1349e5108f8b3085981ead",
                "shasum": ""
            },
            "require": {
                "ext-curl": "*",
                "symfony/console": "~2.0"
            },
            "bin": [
                "security-checker"
            ],
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.0-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "SensioLabs\\Security": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "A security checker for your composer.lock",
            "time": "2015-05-22 14:21:04"
        },
        {
            "name": "swiftmailer/swiftmailer",
            "version": "v5.4.0",
            "source": {
                "type": "git",
                "url": "https://github.com/swiftmailer/swiftmailer.git",
                "reference": "31454f258f10329ae7c48763eb898a75c39e0a9f"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/swiftmailer/swiftmailer/zipball/31454f258f10329ae7c48763eb898a75c39e0a9f",
                "reference": "31454f258f10329ae7c48763eb898a75c39e0a9f",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.3"
            },
            "require-dev": {
                "mockery/mockery": "~0.9.1"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "5.4-dev"
                }
            },
            "autoload": {
                "files": [
                    "lib/swift_required.php"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Chris Corbyn"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Swiftmailer, free feature-rich PHP mailer",
            "homepage": "http://swiftmailer.org",
            "keywords": [
                "mail",
                "mailer"
            ],
            "time": "2015-03-14 06:06:39"
        },
        {
            "name": "symfony/assetic-bundle",
            "version": "v2.6.1",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/AsseticBundle.git",
                "reference": "422b0add2110f0cf9bc7a873a386ea053f4a89f0"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/symfony/AsseticBundle/zipball/422b0add2110f0cf9bc7a873a386ea053f4a89f0",
                "reference": "422b0add2110f0cf9bc7a873a386ea053f4a89f0",
                "shasum": ""
            },
            "require": {
                "kriswallsmith/assetic": "~1.2",
                "php": ">=5.3.0",
                "symfony/console": "~2.3",
                "symfony/dependency-injection": "~2.3",
                "symfony/framework-bundle": "~2.3",
                "symfony/yaml": "~2.3"
            },
            "require-dev": {
                "kriswallsmith/spork": "~0.2",
                "patchwork/jsqueeze": "~1.0",
                "symfony/class-loader": "~2.3",
                "symfony/css-selector": "~2.3",
                "symfony/dom-crawler": "~2.3",
                "symfony/twig-bundle": "~2.3"
            },
            "suggest": {
                "kriswallsmith/spork": "to be able to dump assets in parallel",
                "symfony/twig-bundle": "to use the Twig integration"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.5-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Symfony\\Bundle\\AsseticBundle\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Kris Wallsmith",
                    "email": "[email protected]",
                    "homepage": "http://kriswallsmith.net/"
                }
            ],
            "description": "Integrates Assetic into Symfony2",
            "homepage": "https://github.com/symfony/AsseticBundle",
            "keywords": [
                "assets",
                "compression",
                "minification"
            ],
            "time": "2015-01-27 12:45:16"
        },
        {
            "name": "symfony/intl",
            "version": "dev-master",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/Intl.git",
                "reference": "64c72f588cdb717d9217121199ef43a93e55640e"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/symfony/Intl/zipball/64c72f588cdb717d9217121199ef43a93e55640e",
                "reference": "64c72f588cdb717d9217121199ef43a93e55640e",
                "shasum": ""
            },
            "require": {
                "php": ">=5.5.9"
            },
            "require-dev": {
                "symfony/filesystem": "~2.8|~3.0",
                "symfony/phpunit-bridge": "~2.8|~3.0"
            },
            "suggest": {
                "ext-intl": "to use the component with locales other than \"en\""
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "3.0-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Symfony\\Component\\Intl\\": ""
                },
                "classmap": [
                    "Resources/stubs"
                ],
                "files": [
                    "Resources/stubs/functions.php"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Bernhard Schussek",
                    "email": "[email protected]"
                },
                {
                    "name": "Eriksen Costa",
                    "email": "[email protected]"
                },
                {
                    "name": "Igor Wiedler",
                    "email": "[email protected]"
                },
                {
                    "name": "Symfony Community",
                    "homepage": "https://symfony.com/contributors"
                }
            ],
            "description": "A PHP replacement layer for the C intl extension that includes additional data from the ICU library.",
            "homepage": "https://symfony.com",
            "keywords": [
                "i18n",
                "icu",
                "internationalization",
                "intl",
                "l10n",
                "localization"
            ],
            "time": "2015-05-15 14:16:35"
        },
        {
            "name": "symfony/monolog-bundle",
            "version": "v2.7.1",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/MonologBundle.git",
                "reference": "9320b6863404c70ebe111e9040dab96f251de7ac"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/symfony/MonologBundle/zipball/9320b6863404c70ebe111e9040dab96f251de7ac",
                "reference": "9320b6863404c70ebe111e9040dab96f251de7ac",
                "shasum": ""
            },
            "require": {
                "monolog/monolog": "~1.8",
                "php": ">=5.3.2",
                "symfony/config": "~2.3",
                "symfony/dependency-injection": "~2.3",
                "symfony/http-kernel": "~2.3",
                "symfony/monolog-bridge": "~2.3"
            },
            "require-dev": {
                "symfony/console": "~2.3",
                "symfony/yaml": "~2.3"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.7.x-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Symfony\\Bundle\\MonologBundle\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Symfony Community",
                    "homepage": "http://symfony.com/contributors"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony MonologBundle",
            "homepage": "http://symfony.com",
            "keywords": [
                "log",
                "logging"
            ],
            "time": "2015-01-04 20:21:17"
        },
        {
            "name": "symfony/swiftmailer-bundle",
            "version": "v2.3.8",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/SwiftmailerBundle.git",
                "reference": "970b13d01871207e81d17b17ddda025e7e21e797"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/symfony/SwiftmailerBundle/zipball/970b13d01871207e81d17b17ddda025e7e21e797",
                "reference": "970b13d01871207e81d17b17ddda025e7e21e797",
                "shasum": ""
            },
            "require": {
                "php": ">=5.3.2",
                "swiftmailer/swiftmailer": ">=4.2.0,~5.0",
                "symfony/swiftmailer-bridge": "~2.1"
            },
            "require-dev": {
                "symfony/config": "~2.1",
                "symfony/dependency-injection": "~2.1",
                "symfony/http-kernel": "~2.1",
                "symfony/yaml": "~2.1"
            },
            "suggest": {
                "psr/log": "Allows logging"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.3-dev"
                }
            },
            "autoload": {
                "psr-4": {
                    "Symfony\\Bundle\\SwiftmailerBundle\\": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Symfony Community",
                    "homepage": "http://symfony.com/contributors"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Symfony SwiftmailerBundle",
            "homepage": "http://symfony.com",
            "time": "2014-12-01 17:44:50"
        },
        {
            "name": "symfony/symfony",
            "version": "v2.6.7",
            "source": {
                "type": "git",
                "url": "https://github.com/symfony/symfony.git",
                "reference": "0449d0e1178bc8e934520b20432d1705c3b25e7e"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/symfony/symfony/zipball/0449d0e1178bc8e934520b20432d1705c3b25e7e",
                "reference": "0449d0e1178bc8e934520b20432d1705c3b25e7e",
                "shasum": ""
            },
            "require": {
                "doctrine/common": "~2.3",
                "php": ">=5.3.3",
                "psr/log": "~1.0",
                "twig/twig": "~1.12,>=1.12.3"
            },
            "replace": {
                "symfony/browser-kit": "self.version",
                "symfony/class-loader": "self.version",
                "symfony/config": "self.version",
                "symfony/console": "self.version",
                "symfony/css-selector": "self.version",
                "symfony/debug": "self.version",
                "symfony/debug-bundle": "self.version",
                "symfony/dependency-injection": "self.version",
                "symfony/doctrine-bridge": "self.version",
                "symfony/dom-crawler": "self.version",
                "symfony/event-dispatcher": "self.version",
                "symfony/expression-language": "self.version",
                "symfony/filesystem": "self.version",
                "symfony/finder": "self.version",
                "symfony/form": "self.version",
                "symfony/framework-bundle": "self.version",
                "symfony/http-foundation": "self.version",
                "symfony/http-kernel": "self.version",
                "symfony/intl": "self.version",
                "symfony/locale": "self.version",
                "symfony/monolog-bridge": "self.version",
                "symfony/options-resolver": "self.version",
                "symfony/process": "self.version",
                "symfony/propel1-bridge": "self.version",
                "symfony/property-access": "self.version",
                "symfony/proxy-manager-bridge": "self.version",
                "symfony/routing": "self.version",
                "symfony/security": "self.version",
                "symfony/security-acl": "self.version",
                "symfony/security-bundle": "self.version",
                "symfony/security-core": "self.version",
                "symfony/security-csrf": "self.version",
                "symfony/security-http": "self.version",
                "symfony/serializer": "self.version",
                "symfony/stopwatch": "self.version",
                "symfony/swiftmailer-bridge": "self.version",
                "symfony/templating": "self.version",
                "symfony/translation": "self.version",
                "symfony/twig-bridge": "self.version",
                "symfony/twig-bundle": "self.version",
                "symfony/validator": "self.version",
                "symfony/var-dumper": "self.version",
                "symfony/web-profiler-bundle": "self.version",
                "symfony/yaml": "self.version"
            },
            "require-dev": {
                "doctrine/data-fixtures": "1.0.*",
                "doctrine/dbal": "~2.2",
                "doctrine/doctrine-bundle": "~1.2",
                "doctrine/orm": "~2.2,>=2.2.3",
                "egulias/email-validator": "~1.2",
                "ircmaxell/password-compat": "~1.0",
                "monolog/monolog": "~1.11",
                "ocramius/proxy-manager": "~0.4|~1.0",
                "propel/propel1": "~1.6",
                "symfony/phpunit-bridge": "~2.7"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.6-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Symfony\\": "src/"
                },
                "classmap": [
                    "src/Symfony/Component/HttpFoundation/Resources/stubs",
                    "src/Symfony/Component/Intl/Resources/stubs"
                ],
                "files": [
                    "src/Symfony/Component/Intl/Resources/stubs/functions.php"
                ]
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Symfony Community",
                    "homepage": "http://symfony.com/contributors"
                },
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "The Symfony PHP framework",
            "homepage": "http://symfony.com",
            "keywords": [
                "framework"
            ],
            "time": "2015-05-11 01:58:49"
        },
        {
            "name": "twig/extensions",
            "version": "v1.2.0",
            "source": {
                "type": "git",
                "url": "https://github.com/twigphp/Twig-extensions.git",
                "reference": "8cf4b9fe04077bd54fc73f4fde83347040c3b8cd"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/twigphp/Twig-extensions/zipball/8cf4b9fe04077bd54fc73f4fde83347040c3b8cd",
                "reference": "8cf4b9fe04077bd54fc73f4fde83347040c3b8cd",
                "shasum": ""
            },
            "require": {
                "twig/twig": "~1.12"
            },
            "require-dev": {
                "symfony/translation": "~2.3"
            },
            "suggest": {
                "symfony/translation": "Allow the time_diff output to be translated"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.2.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Twig_Extensions_": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "Common additional features for Twig that do not directly belong in core",
            "homepage": "http://twig.sensiolabs.org/doc/extensions/index.html",
            "keywords": [
                "i18n",
                "text"
            ],
            "time": "2014-10-30 14:30:03"
        },
        {
            "name": "twig/twig",
            "version": "v1.18.1",
            "source": {
                "type": "git",
                "url": "https://github.com/twigphp/Twig.git",
                "reference": "9f70492f44398e276d1b81c1b43adfe6751c7b7f"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/twigphp/Twig/zipball/9f70492f44398e276d1b81c1b43adfe6751c7b7f",
                "reference": "9f70492f44398e276d1b81c1b43adfe6751c7b7f",
                "shasum": ""
            },
            "require": {
                "php": ">=5.2.7"
            },
            "type": "library",
            "extra": {
                "branch-alias": {
                    "dev-master": "1.18-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Twig_": "lib/"
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "BSD-3-Clause"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]",
                    "homepage": "http://fabien.potencier.org",
                    "role": "Lead Developer"
                },
                {
                    "name": "Armin Ronacher",
                    "email": "[email protected]",
                    "role": "Project Founder"
                },
                {
                    "name": "Twig Team",
                    "homepage": "http://twig.sensiolabs.org/contributors",
                    "role": "Contributors"
                }
            ],
            "description": "Twig, the flexible, fast, and secure template language for PHP",
            "homepage": "http://twig.sensiolabs.org",
            "keywords": [
                "templating"
            ],
            "time": "2015-04-19 08:30:27"
        }
    ],
    "packages-dev": [
        {
            "name": "sensio/generator-bundle",
            "version": "v2.5.3",
            "target-dir": "Sensio/Bundle/GeneratorBundle",
            "source": {
                "type": "git",
                "url": "https://github.com/sensiolabs/SensioGeneratorBundle.git",
                "reference": "e50108c2133ee5c9c484555faed50c17a61221d3"
            },
            "dist": {
                "type": "zip",
                "url": "https://api.github.com/repos/sensiolabs/SensioGeneratorBundle/zipball/e50108c2133ee5c9c484555faed50c17a61221d3",
                "reference": "e50108c2133ee5c9c484555faed50c17a61221d3",
                "shasum": ""
            },
            "require": {
                "symfony/console": "~2.5",
                "symfony/framework-bundle": "~2.2"
            },
            "require-dev": {
                "doctrine/orm": "~2.2,>=2.2.3",
                "symfony/doctrine-bridge": "~2.2",
                "twig/twig": "~1.11"
            },
            "type": "symfony-bundle",
            "extra": {
                "branch-alias": {
                    "dev-master": "2.5.x-dev"
                }
            },
            "autoload": {
                "psr-0": {
                    "Sensio\\Bundle\\GeneratorBundle": ""
                }
            },
            "notification-url": "https://packagist.org/downloads/",
            "license": [
                "MIT"
            ],
            "authors": [
                {
                    "name": "Fabien Potencier",
                    "email": "[email protected]"
                }
            ],
            "description": "This bundle generates code for you",
            "time": "2015-03-17 06:36:52"
        }
    ],
    "aliases": [],
    "minimum-stability": "stable",
    "stability-flags": {
        "symfony/intl": 20,
        "gedmo/doctrine-extensions": 20,
        "knplabs/doctrine-behaviors": 20,
        "jms/di-extra-bundle": 20,
        "jms/security-extra-bundle": 20,
        "jms/serializer-bundle": 20,
        "lexik/translation-bundle": 20,
        "friendsofsymfony/user-bundle": 20,
        "jms/i18n-routing-bundle": 20,
        "google/apiclient": 10
    },
    "prefer-stable": false,
    "prefer-lowest": false,
    "platform": {
        "php": ">=5.3.3"
    },
    "platform-dev": []
 }
diff --git a/Santander_Gemfile b/Santander_Gemfile
 source "https://rubygems.org"

 gem 'capistrano'
 gem 'capistrano-symfony'
diff --git a/Santander_Gemfile.lock b/Santander_Gemfile.lock
 GEM
  remote: https://rubygems.org/
  specs:
    capistrano (3.4.0)
      i18n
      rake (>= 10.0.0)
      sshkit (~> 1.3)
    capistrano-composer (0.0.6)
      capistrano (>= 3.0.0.pre)
    capistrano-file-permissions (0.1.0)
      capistrano (>= 3.0.0)
    capistrano-symfony (0.4.0)
      capistrano (~> 3.1)
      capistrano-composer (~> 0.0.3)
      capistrano-file-permissions (~> 0.1.0)
    colorize (0.7.5)
    i18n (0.7.0)
    net-scp (1.2.1)
      net-ssh (>= 2.6.5)
    net-ssh (2.9.2)
    rake (10.4.2)
    sshkit (1.7.1)
      colorize (>= 0.7.0)
      net-scp (>= 1.1.2)
      net-ssh (>= 2.8.0)

 PLATFORMS
  ruby

 DEPENDENCIES
  capistrano
  capistrano-symfony
diff --git a/Santander_README.md b/Santander_README.md
diff --git a/Santander_composer.phar b/Santander_composer.phar
 #!/usr/bin/env php
 <?php
 /*
 * This file is part of Composer.
 *
 * (c) Nils Adermann <[email protected]>
 *     Jordi Boggiano <[email protected]>
 *
 * For the full copyright and license information, please view
 * the license that is located at the bottom of this file.
 */

 // Avoid APC causing random fatal errors per https://github.com/composer/composer/issues/264
 if (extension_loaded('apc') && ini_get('apc.enable_cli') && ini_get('apc.cache_by_default')) {
    if (version_compare(phpversion('apc'), '3.0.12', '>=')) {
        ini_set('apc.cache_by_default', 0);
    } else {
        fwrite(STDERR, 'Warning: APC <= 3.0.12 may cause fatal errors when running composer commands.'.PHP_EOL);
        fwrite(STDERR, 'Update APC, or set apc.enable_cli or apc.cache_by_default to 0 in your php.ini.'.PHP_EOL);
    }
 }

 Phar::mapPhar('composer.phar');
 define('COMPOSER_DEV_WARNING_TIME', 1446199130);
 require 'phar://composer.phar/bin/composer';

 __HALT_COMPILER(); ?>
 >vk
composer.phar+src/Composer/Autoload/AutoloadGenerator.phpnKZ%�UnK�K�e�+src/Composer/Autoload/ClassMapGenerator.phpZ%�U�tx�src/Composer/Cache.php�Z%�U��h�%src/Composer/Command/AboutCommand.php�Z%�U�ZF���'src/Composer/Command/ArchiveCommand.phpZ%�U}�;^�*src/Composer/Command/ClearCacheCommand.phpZZ%�UZ��>� src/Composer/Command/Command.php�Z%�U��vJ�&src/Composer/Command/ConfigCommand.php�5Z%�U�5ܥP��-src/Composer/Command/CreateProjectCommand.php3Z%�U3�-�Ƕ'src/Composer/Command/DependsCommand.php�
 Z%�U�
 �!"�(src/Composer/Command/DiagnoseCommand.php�9Z%�U�9�1�"�,src/Composer/Command/DumpAutoloadCommand.php�Z%�U�FZ�&src/Composer/Command/GlobalCommand.phpZ%�U��@��$src/Composer/Command/HomeCommand.php`
Z%�U`
-y�O�$src/Composer/Command/InitCommand.php`8Z%�U`8�?w�'src/Composer/Command/InstallCommand.php#Z%�U#=J%�(src/Composer/Command/LicensesCommand.php1Z%�U1��h��&src/Composer/Command/RemoveCommand.php^Z%�U^$��y�'src/Composer/Command/RequireCommand.php�Z%�U�9y�B�)src/Composer/Command/RunScriptCommand.php�Z%�U�s�4�+src/Composer/Command/ScriptAliasCommand.php�Z%�U���$��&src/Composer/Command/SearchCommand.phpl	Z%�Ul	�K4�*src/Composer/Command/SelfUpdateCommand.php#Z%�U#�#�)�$src/Composer/Command/ShowCommand.php�1Z%�U�1
;p�&src/Composer/Command/StatusCommand.php�	Z%�U�	bpҶ(src/Composer/Command/SuggestsCommand.php�Z%�U��?gж&src/Composer/Command/UpdateCommand.php*Z%�U*�
 #ö(src/Composer/Command/ValidateCommand.php�
Z%�U�
�ザsrc/Composer/Composer.php)	Z%�U)	�>v�src/Composer/Config.phpZ%�U瓏^�-src/Composer/Config/ConfigSourceInterface.php�Z%�U�6J[��(src/Composer/Config/JsonConfigSource.php�Z%�U�*��T�$src/Composer/Console/Application.php|!Z%�U|!㡱Ӷ,src/Composer/Console/HtmlOutputFormatter.php1Z%�U1�����/src/Composer/DependencyResolver/DebugSolver.php�Z%�U��ҭ��-src/Composer/DependencyResolver/Decisions.phpQZ%�UQ?��$�1src/Composer/DependencyResolver/DefaultPolicy.php�Z%�U��ho��>src/Composer/DependencyResolver/Operation/InstallOperation.phpCZ%�UC�\�*�Isrc/Composer/DependencyResolver/Operation/MarkAliasInstalledOperation.php�Z%�U������Ksrc/Composer/DependencyResolver/Operation/MarkAliasUninstalledOperation.php�Z%�U�3#��@src/Composer/DependencyResolver/Operation/OperationInterface.php�Z%�U���&�=src/Composer/DependencyResolver/Operation/SolverOperation.php�Z%�U�&�e
 �@src/Composer/DependencyResolver/Operation/UninstallOperation.phpIZ%�UIF��ɶ=src/Composer/DependencyResolver/Operation/UpdateOperation.phphZ%�Uh�S�]�3src/Composer/DependencyResolver/PolicyInterface.php�Z%�U�n�&��(src/Composer/DependencyResolver/Pool.phpR"Z%�UR"�$/�+src/Composer/DependencyResolver/Problem.php�Z%�U��V��+src/Composer/DependencyResolver/Request.php�Z%�U�fDC�(src/Composer/DependencyResolver/Rule.php�Z%�U����+src/Composer/DependencyResolver/RuleSet.php
 Z%�U
 :Z�E�4src/Composer/DependencyResolver/RuleSetGenerator.php]Z%�U]4��9�3src/Composer/DependencyResolver/RuleSetIterator.phpZ%�U}���2src/Composer/DependencyResolver/RuleWatchChain.phpiZ%�Uih�,�2src/Composer/DependencyResolver/RuleWatchGraph.php�Z%�U��8�1src/Composer/DependencyResolver/RuleWatchNode.php�Z%�U���ȶ*src/Composer/DependencyResolver/Solver.phpd7Z%�Ud7P�
 �6src/Composer/DependencyResolver/SolverBugException.php�Z%�U�"qN�;src/Composer/DependencyResolver/SolverProblemsException.php(Z%�U(S����/src/Composer/DependencyResolver/Transaction.php�Z%�U��3��-src/Composer/Downloader/ArchiveDownloader.php�Z%�U������1src/Composer/Downloader/ChangeReportInterface.php�Z%�U��ਿ�+src/Composer/Downloader/DownloadManager.php�Z%�U�'o�b�/src/Composer/Downloader/DownloaderInterface.php�Z%�U�gs!l�*src/Composer/Downloader/FileDownloader.phpnZ%�Un�t���/src/Composer/Downloader/FilesystemException.phpZ%�U]T���)src/Composer/Downloader/GitDownloader.php�$Z%�U�$�� �*src/Composer/Downloader/GzipDownloader.php�Z%�U����ж(src/Composer/Downloader/HgDownloader.phpdZ%�Ud�.��0src/Composer/Downloader/PearPackageExtractor.phpvZ%�Uv2�M�.src/Composer/Downloader/PerforceDownloader.phpxZ%�Ux<�c�*src/Composer/Downloader/PharDownloader.php�Z%�U����)src/Composer/Downloader/RarDownloader.php�Z%�U����)src/Composer/Downloader/SvnDownloader.php]Z%�U]�<l�)src/Composer/Downloader/TarDownloader.php�Z%�U�͒X?�.src/Composer/Downloader/TransportException.php�Z%�U�h"Br�)src/Composer/Downloader/VcsDownloader.php�Z%�U�N+��)src/Composer/Downloader/ZipDownloader.phpCZ%�UC]^+�&src/Composer/EventDispatcher/Event.php�Z%�U���j�0src/Composer/EventDispatcher/EventDispatcher.php5Z%�U5%�Ŷ9src/Composer/EventDispatcher/EventSubscriberInterface.php�Z%�U�h�0�src/Composer/Factory.php-Z%�U-�~���src/Composer/IO/BaseIO.phppZ%�Up�N�Z�src/Composer/IO/BufferIO.phpZ%�Uhv�src/Composer/IO/ConsoleIO.php8Z%�U8����src/Composer/IO/IOInterface.php�Z%�U�
 ��8�src/Composer/IO/NullIO.php�Z%�U�~1Ķsrc/Composer/Installer.php��Z%�U���צ�.src/Composer/Installer/InstallationManager.php@Z%�U@����)src/Composer/Installer/InstallerEvent.phpZ%�Ul�zi�*src/Composer/Installer/InstallerEvents.php�Z%�U��@G�-src/Composer/Installer/InstallerInterface.php�Z%�U�^��ʶ+src/Composer/Installer/LibraryInstaller.php�Z%�U�����/src/Composer/Installer/MetapackageInstaller.php�Z%�U���!�(src/Composer/Installer/NoopInstaller.php+Z%�U+��M}�'src/Composer/Installer/PackageEvent.phpeZ%�Ue;� �(src/Composer/Installer/PackageEvents.php�Z%�U�db�s�(src/Composer/Installer/PearInstaller.phpVZ%�UV�z��*src/Composer/Installer/PluginInstaller.php
 Z%�U
 6���+src/Composer/Installer/ProjectInstaller.phpZ%�U*0@P�src/Composer/Json/JsonFile.phpZ%�U����#src/Composer/Json/JsonFormatter.phpZ%�Uc�]Y�%src/Composer/Json/JsonManipulator.php*Z%�U*r%�-src/Composer/Json/JsonValidationException.php\Z%�U\.X�ܶ%src/Composer/Package/AliasPackage.phpZ%�UR��ж7src/Composer/Package/Archiver/ArchivableFilesFinder.php�Z%�U����ɶ0src/Composer/Package/Archiver/ArchiveManager.php'Z%�U'����3src/Composer/Package/Archiver/ArchiverInterface.php�Z%�U�<ʸ�3src/Composer/Package/Archiver/BaseExcludeFilter.php�Z%�U�[�0=�7src/Composer/Package/Archiver/ComposerExcludeFilter.phpZ%�U�SZ0�2src/Composer/Package/Archiver/GitExcludeFilter.phpwZ%�UwLgU��1src/Composer/Package/Archiver/HgExcludeFilter.phpZ%�U~���.src/Composer/Package/Archiver/PharArchiver.php[Z%�U[�5��$src/Composer/Package/BasePackage.php�Z%�U����(src/Composer/Package/CompletePackage.php�Z%�U�o+�	�1src/Composer/Package/CompletePackageInterface.php�Z%�U��ʁ�+src/Composer/Package/Dumper/ArrayDumper.php�Z%�U����src/Composer/Package/Link.phpQZ%�UQn]qz�7src/Composer/Package/LinkConstraint/EmptyConstraint.php�Z%�U����?src/Composer/Package/LinkConstraint/LinkConstraintInterface.phpZ%�U�����7src/Composer/Package/LinkConstraint/MultiConstraint.phpgZ%�Ugs3�:src/Composer/Package/LinkConstraint/SpecificConstraint.phppZ%�Up_��Y�9src/Composer/Package/LinkConstraint/VersionConstraint.php�Z%�U���*�+src/Composer/Package/Loader/ArrayLoader.php�Z%�U�bU=�7src/Composer/Package/Loader/InvalidPackageException.phpEZ%�UExb��*src/Composer/Package/Loader/JsonLoader.php�Z%�U�!~�{�/src/Composer/Package/Loader/LoaderInterface.php�Z%�U��}�ζ1src/Composer/Package/Loader/RootPackageLoader.php�"Z%�U�"d�mE�5src/Composer/Package/Loader/ValidatingArrayLoader.php�/Z%�U�/[�C�src/Composer/Package/Locker.php�Z%�U����;� src/Composer/Package/Package.php�Z%�U����)src/Composer/Package/PackageInterface.php�Z%�U���^ƶ)src/Composer/Package/RootAliasPackage.phpyZ%�Uy�E'�$src/Composer/Package/RootPackage.phpnZ%�Un�ACO�-src/Composer/Package/RootPackageInterface.php�Z%�U��qKж.src/Composer/Package/Version/VersionParser.php�-Z%�U�-)���0src/Composer/Package/Version/VersionSelector.php�Z%�U��j6�$src/Composer/Plugin/CommandEvent.php�Z%�U����W�$src/Composer/Plugin/PluginEvents.php�Z%�U�0��X�'src/Composer/Plugin/PluginInterface.php�Z%�U�1�%�%src/Composer/Plugin/PluginManager.php�Z%�U���j�,src/Composer/Plugin/PreFileDownloadEvent.php`Z%�U`9-ζ+src/Composer/Repository/ArrayRepository.php�
Z%�U�
7��Ƕ.src/Composer/Repository/ArtifactRepository.phpZ%�UZ|/�.src/Composer/Repository/ComposerRepository.phpr@Z%�Ur@qk���/src/Composer/Repository/CompositeRepository.php.Z%�U.C�x�0src/Composer/Repository/FilesystemRepository.php�Z%�U�&xb��4src/Composer/Repository/InstalledArrayRepository.php�Z%�U�/�~>�9src/Composer/Repository/InstalledFilesystemRepository.php�Z%�U�V
 �_�8src/Composer/Repository/InstalledRepositoryInterface.php�Z%�U��9p�6src/Composer/Repository/InvalidRepositoryException.phpnZ%�Un��똶-src/Composer/Repository/PackageRepository.phpGZ%�UG�:k�2src/Composer/Repository/Pear/BaseChannelReader.php6Z%�U6.fi!�,src/Composer/Repository/Pear/ChannelInfo.php�Z%�U�:T*ɶ.src/Composer/Repository/Pear/ChannelReader.phpnZ%�Un�8�4src/Composer/Repository/Pear/ChannelRest10Reader.php�	Z%�U�	O��4src/Composer/Repository/Pear/ChannelRest11Reader.php&	Z%�U&	�Ub�5src/Composer/Repository/Pear/DependencyConstraint.phpqZ%�Uq9=�/src/Composer/Repository/Pear/DependencyInfo.phpqZ%�Uqf�T�8src/Composer/Repository/Pear/PackageDependencyParser.php%Z%�U%j?��,src/Composer/Repository/Pear/PackageInfo.php�Z%�U��
��,src/Composer/Repository/Pear/ReleaseInfo.php�Z%�U�o��ö*src/Composer/Repository/PearRepository.php�Z%�U�
 ,B��.src/Composer/Repository/PlatformRepository.php�Z%�U�IЗƶ/src/Composer/Repository/RepositoryInterface.php�Z%�U�7@��-src/Composer/Repository/RepositoryManager.php�Z%�U��Y�I�7src/Composer/Repository/RepositorySecurityException.phpoZ%�Uopի��2src/Composer/Repository/Vcs/GitBitbucketDriver.php�Z%�U�F���)src/Composer/Repository/Vcs/GitDriver.phpZ%�U\��,src/Composer/Repository/Vcs/GitHubDriver.php�'Z%�U�'��@�1src/Composer/Repository/Vcs/HgBitbucketDriver.php�
Z%�U�
��W��(src/Composer/Repository/Vcs/HgDriver.php�Z%�U��綶.src/Composer/Repository/Vcs/PerforceDriver.php!
 Z%�U!
 ���k�)src/Composer/Repository/Vcs/SvnDriver.php�Z%�U�� W�)src/Composer/Repository/Vcs/VcsDriver.php�Z%�U��%R�2src/Composer/Repository/Vcs/VcsDriverInterface.php�Z%�U�pO㤶)src/Composer/Repository/VcsRepository.phpDZ%�UD�zY�3src/Composer/Repository/WritableArrayRepository.phpZ%�U�G*�7src/Composer/Repository/WritableRepositoryInterface.php�Z%�U��/s�$src/Composer/Script/CommandEvent.phpWZ%�UW�VZt�src/Composer/Script/Event.php�Z%�U�lt�M�$src/Composer/Script/PackageEvent.php�Z%�U����
�$src/Composer/Script/ScriptEvents.phpPZ%�UP���� src/Composer/Util/AuthHelper.php�Z%�U�>zx��$src/Composer/Util/ComposerMirror.php�Z%�U����ض%src/Composer/Util/ConfigValidator.phpNZ%�UNǭ�Ӷ"src/Composer/Util/ErrorHandler.phpYZ%�UY�vB� src/Composer/Util/Filesystem.phpG&Z%�UG&7r���src/Composer/Util/Git.phpZ%�U�kV��src/Composer/Util/GitHub.php�
 Z%�U�
 ��'��$src/Composer/Util/NoProxyPattern.php�Z%�U�Z+�m�src/Composer/Util/Perforce.php3Z%�U3�=e.�%src/Composer/Util/ProcessExecutor.php�Z%�U����&src/Composer/Util/RemoteFilesystem.php�+Z%�U�+�Je9�!src/Composer/Util/SpdxLicense.phpZ%�U�@���*src/Composer/Util/StreamContextFactory.php�Z%�U���Y�src/Composer/Util/Svn.php�Z%�U���eZ�src/bootstrap.php�Z%�U���2��%src/Composer/Autoload/ClassLoader.php�0Z%�U�0�Lh��res/composer-schema.json7UZ%�U7U)��>�6vendor/composer/spdx-licenses/res/spdx-exceptions.json�Z%�U�7J�S�4vendor/composer/spdx-licenses/res/spdx-licenses.json�]Z%�U�]%z"��*vendor/seld/cli-prompt/res/hiddeninput.exe$Z%�U$���v�@vendor/symfony/console/Symfony/Component/Console/Application.php�RZ%�U�R?sK�Dvendor/symfony/console/Symfony/Component/Console/Command/Command.php�Z%�U�p��Hvendor/symfony/console/Symfony/Component/Console/Command/HelpCommand.php6Z%�U6#��}�Hvendor/symfony/console/Symfony/Component/Console/Command/ListCommand.php�Z%�U�V��Bvendor/symfony/console/Symfony/Component/Console/ConsoleEvents.php�Z%�U�
�H��Vvendor/symfony/console/Symfony/Component/Console/Descriptor/ApplicationDescription.phpZ%�U�0�j�Jvendor/symfony/console/Symfony/Component/Console/Descriptor/Descriptor.php\Z%�U\WJ[�Svendor/symfony/console/Symfony/Component/Console/Descriptor/DescriptorInterface.php�Z%�U��Q��Nvendor/symfony/console/Symfony/Component/Console/Descriptor/JsonDescriptor.php2
Z%�U2
�ca�Rvendor/symfony/console/Symfony/Component/Console/Descriptor/MarkdownDescriptor.php
 Z%�U
 L�*�Nvendor/symfony/console/Symfony/Component/Console/Descriptor/TextDescriptor.php4Z%�U4`��8�Mvendor/symfony/console/Symfony/Component/Console/Descriptor/XmlDescriptor.php�Z%�U��{�m�Nvendor/symfony/console/Symfony/Component/Console/Event/ConsoleCommandEvent.php�Z%�U�Zk�2�Gvendor/symfony/console/Symfony/Component/Console/Event/ConsoleEvent.php�Z%�U��x�\�Pvendor/symfony/console/Symfony/Component/Console/Event/ConsoleExceptionEvent.phpZ%�U�2�Pvendor/symfony/console/Symfony/Component/Console/Event/ConsoleTerminateEvent.phpzZ%�Uz�,�L�Nvendor/symfony/console/Symfony/Component/Console/Formatter/OutputFormatter.php�Z%�U�%�Ҭ�Wvendor/symfony/console/Symfony/Component/Console/Formatter/OutputFormatterInterface.php�Z%�U�3l~��Svendor/symfony/console/Symfony/Component/Console/Formatter/OutputFormatterStyle.phpZ%�U,{Z��\vendor/symfony/console/Symfony/Component/Console/Formatter/OutputFormatterStyleInterface.php�Z%�U����=�Xvendor/symfony/console/Symfony/Component/Console/Formatter/OutputFormatterStyleStack.php
 Z%�U
 ,�-�Pvendor/symfony/console/Symfony/Component/Console/Helper/DebugFormatterHelper.phpxZ%�Ux�H@�Lvendor/symfony/console/Symfony/Component/Console/Helper/DescriptorHelper.php9Z%�U9����Hvendor/symfony/console/Symfony/Component/Console/Helper/DialogHelper.php�Z%�U��=�ӶKvendor/symfony/console/Symfony/Component/Console/Helper/FormatterHelper.phpcZ%�Uc��N�Bvendor/symfony/console/Symfony/Component/Console/Helper/Helper.php�Z%�U�o��Kvendor/symfony/console/Symfony/Component/Console/Helper/HelperInterface.php�Z%�U�=e�Evendor/symfony/console/Symfony/Component/Console/Helper/HelperSet.php/Z%�U/�wd�Lvendor/symfony/console/Symfony/Component/Console/Helper/InputAwareHelper.phpcZ%�Uc��|�Ivendor/symfony/console/Symfony/Component/Console/Helper/ProcessHelper.php�Z%�U�|̼�Gvendor/symfony/console/Symfony/Component/Console/Helper/ProgressBar.php$Z%�U$��Jvendor/symfony/console/Symfony/Component/Console/Helper/ProgressHelper.php�Z%�U��h��Jvendor/symfony/console/Symfony/Component/Console/Helper/QuestionHelper.phpZ%�UR��Avendor/symfony/console/Symfony/Component/Console/Helper/Table.phpZ%�U��A)�Gvendor/symfony/console/Symfony/Component/Console/Helper/TableHelper.php�
 Z%�U�
 ,
��Jvendor/symfony/console/Symfony/Component/Console/Helper/TableSeparator.php[Z%�U[LV��Fvendor/symfony/console/Symfony/Component/Console/Helper/TableStyle.php�Z%�U��"��Dvendor/symfony/console/Symfony/Component/Console/Input/ArgvInput.php�Z%�U��Ѝ�Evendor/symfony/console/Symfony/Component/Console/Input/ArrayInput.php�	Z%�U�	���p�@vendor/symfony/console/Symfony/Component/Console/Input/Input.php
 Z%�U
 ��T�Hvendor/symfony/console/Symfony/Component/Console/Input/InputArgument.php�Z%�U�K]�i�Nvendor/symfony/console/Symfony/Component/Console/Input/InputAwareInterface.php�Z%�U��jT��Jvendor/symfony/console/Symfony/Component/Console/Input/InputDefinition.phpZ%�U��JM�Ivendor/symfony/console/Symfony/Component/Console/Input/InputInterface.php Z%�U 9��ǶFvendor/symfony/console/Symfony/Component/Console/Input/InputOption.php�Z%�U�ꆮ��Fvendor/symfony/console/Symfony/Component/Console/Input/StringInput.php�Z%�U��un�8vendor/symfony/console/Symfony/Component/Console/LICENSE)Z%�U)�&��Ivendor/symfony/console/Symfony/Component/Console/Logger/ConsoleLogger.php;	Z%�U;	#�B~�Jvendor/symfony/console/Symfony/Component/Console/Output/BufferedOutput.php_Z%�U_�Bͷ�Ivendor/symfony/console/Symfony/Component/Console/Output/ConsoleOutput.php�Z%�U�)m�Rvendor/symfony/console/Symfony/Component/Console/Output/ConsoleOutputInterface.php�Z%�U�rN��Fvendor/symfony/console/Symfony/Component/Console/Output/NullOutput.php�Z%�U�`5E˶Bvendor/symfony/console/Symfony/Component/Console/Output/Output.php�Z%�U�� _�Kvendor/symfony/console/Symfony/Component/Console/Output/OutputInterface.phpIZ%�UI���B�Hvendor/symfony/console/Symfony/Component/Console/Output/StreamOutput.php�Z%�U��_նLvendor/symfony/console/Symfony/Component/Console/Question/ChoiceQuestion.php^Z%�U^C��۶Rvendor/symfony/console/Symfony/Component/Console/Question/ConfirmationQuestion.phpKZ%�UK��TȶFvendor/symfony/console/Symfony/Component/Console/Question/Question.php�Z%�U�.e8ֶ:vendor/symfony/console/Symfony/Component/Console/Shell.php1Z%�U1U��,�Mvendor/symfony/console/Symfony/Component/Console/Tester/ApplicationTester.php�Z%�U���d�Ivendor/symfony/console/Symfony/Component/Console/Tester/CommandTester.php�Z%�U�Eٚ|�Jvendor/symfony/finder/Symfony/Component/Finder/Adapter/AbstractAdapter.php�
 Z%�U�
 �)z9�Nvendor/symfony/finder/Symfony/Component/Finder/Adapter/AbstractFindAdapter.php�Z%�U��_��Kvendor/symfony/finder/Symfony/Component/Finder/Adapter/AdapterInterface.php�Z%�U���ȶIvendor/symfony/finder/Symfony/Component/Finder/Adapter/BsdFindAdapter.php{Z%�U{Q,D2�Ivendor/symfony/finder/Symfony/Component/Finder/Adapter/GnuFindAdapter.php^Z%�U^�z�r�Evendor/symfony/finder/Symfony/Component/Finder/Adapter/PhpAdapter.php+Z%�U+&��ҶHvendor/symfony/finder/Symfony/Component/Finder/Comparator/Comparator.php�Z%�U�w�T�Lvendor/symfony/finder/Symfony/Component/Finder/Comparator/DateComparator.php%Z%�U%L�EǶNvendor/symfony/finder/Symfony/Component/Finder/Comparator/NumberComparator.php~Z%�U~�� x�Rvendor/symfony/finder/Symfony/Component/Finder/Exception/AccessDeniedException.php�Z%�U���s��Tvendor/symfony/finder/Symfony/Component/Finder/Exception/AdapterFailureException.phpZ%�Um�_,�Ovendor/symfony/finder/Symfony/Component/Finder/Exception/ExceptionInterface.php�Z%�U�Gz-�Zvendor/symfony/finder/Symfony/Component/Finder/Exception/OperationNotPermitedException.php�Z%�U�U88�Yvendor/symfony/finder/Symfony/Component/Finder/Exception/ShellCommandFailureException.php$Z%�U$C�sӶHvendor/symfony/finder/Symfony/Component/Finder/Expression/Expression.php}Z%�U}/�c�Bvendor/symfony/finder/Symfony/Component/Finder/Expression/Glob.php�Z%�U�3^��Cvendor/symfony/finder/Symfony/Component/Finder/Expression/Regex.php�Z%�U�S7P�Lvendor/symfony/finder/Symfony/Component/Finder/Expression/ValueInterface.php;Z%�U;��Ӷ9vendor/symfony/finder/Symfony/Component/Finder/Finder.php#Z%�U#��$�7vendor/symfony/finder/Symfony/Component/Finder/Glob.php
Z%�U
� M�Pvendor/symfony/finder/Symfony/Component/Finder/Iterator/CustomFilterIterator.php]Z%�U]t౵�Svendor/symfony/finder/Symfony/Component/Finder/Iterator/DateRangeFilterIterator.phpzZ%�Uz}��Tvendor/symfony/finder/Symfony/Component/Finder/Iterator/DepthRangeFilterIterator.php�Z%�U��0��Zvendor/symfony/finder/Symfony/Component/Finder/Iterator/ExcludeDirectoryFilterIterator.php�Z%�U�"����Mvendor/symfony/finder/Symfony/Component/Finder/Iterator/FilePathsIterator.php�Z%�U����Q�Rvendor/symfony/finder/Symfony/Component/Finder/Iterator/FileTypeFilterIterator.php\Z%�U\p�'��Uvendor/symfony/finder/Symfony/Component/Finder/Iterator/FilecontentFilterIterator.php#Z%�U#�_VǶRvendor/symfony/finder/Symfony/Component/Finder/Iterator/FilenameFilterIterator.php�Z%�U�F ��Jvendor/symfony/finder/Symfony/Component/Finder/Iterator/FilterIterator.php�Z%�U�0��ԶVvendor/symfony/finder/Symfony/Component/Finder/Iterator/MultiplePcreFilterIterator.php�Z%�U���Nvendor/symfony/finder/Symfony/Component/Finder/Iterator/PathFilterIterator.php�Z%�U�E*E�Vvendor/symfony/finder/Symfony/Component/Finder/Iterator/RecursiveDirectoryIterator.phpYZ%�UY���ܶSvendor/symfony/finder/Symfony/Component/Finder/Iterator/SizeRangeFilterIterator.phpgZ%�Ug!ԗ�Lvendor/symfony/finder/Symfony/Component/Finder/Iterator/SortableIterator.php�Z%�U���%�6vendor/symfony/finder/Symfony/Component/Finder/LICENSE)Z%�U)�&��@vendor/symfony/finder/Symfony/Component/Finder/Shell/Command.php�
 Z%�U�
 �_�>vendor/symfony/finder/Symfony/Component/Finder/Shell/Shell.php�Z%�U���ە�>vendor/symfony/finder/Symfony/Component/Finder/SplFileInfo.php�Z%�U���6�Qvendor/symfony/process/Symfony/Component/Process/Exception/ExceptionInterface.phpfZ%�Uf]�>T�Wvendor/symfony/process/Symfony/Component/Process/Exception/InvalidArgumentException.php�Z%�U���+_�Mvendor/symfony/process/Symfony/Component/Process/Exception/LogicException.php�Z%�U� ���Uvendor/symfony/process/Symfony/Component/Process/Exception/ProcessFailedException.php<Z%�U<"w�n�Wvendor/symfony/process/Symfony/Component/Process/Exception/ProcessTimedOutException.phpZ%�U.	��Ovendor/symfony/process/Symfony/Component/Process/Exception/RuntimeException.php�Z%�U���:�Evendor/symfony/process/Symfony/Component/Process/ExecutableFinder.php~Z%�U~+��8vendor/symfony/process/Symfony/Component/Process/LICENSE)Z%�U)�&��Hvendor/symfony/process/Symfony/Component/Process/PhpExecutableFinder.php�Z%�U�}E᪶?vendor/symfony/process/Symfony/Component/Process/PhpProcess.php�Z%�U�����Hvendor/symfony/process/Symfony/Component/Process/Pipes/AbstractPipes.phpZ%�U�|���Ivendor/symfony/process/Symfony/Component/Process/Pipes/PipesInterface.phpDZ%�UDv�Dvendor/symfony/process/Symfony/Component/Process/Pipes/UnixPipes.php�Z%�U��Ut�Gvendor/symfony/process/Symfony/Component/Process/Pipes/WindowsPipes.php�Z%�U�.X��<vendor/symfony/process/Symfony/Component/Process/Process.php�NZ%�U�NZEkv�Cvendor/symfony/process/Symfony/Component/Process/ProcessBuilder.phpZ%�U��y�Avendor/symfony/process/Symfony/Component/Process/ProcessUtils.php�Z%�U�
 c��vendor/seld/jsonlint/LICENSE"Z%�U"a�sy�5vendor/seld/jsonlint/src/Seld/JsonLint/JsonParser.php)1Z%�U)1?5R3�0vendor/seld/jsonlint/src/Seld/JsonLint/Lexer.phpZ%�U��m!�;vendor/seld/jsonlint/src/Seld/JsonLint/ParsingException.phpZ%�U���4vendor/seld/jsonlint/src/Seld/JsonLint/Undefined.php>Z%�U>�q���vendor/seld/cli-prompt/LICENSE"Z%�U"��?e�&vendor/seld/cli-prompt/res/example.php'Z%�U'I��(vendor/seld/cli-prompt/src/CliPrompt.phpZ%�U��v�(vendor/justinrainbow/json-schema/LICENSE�Z%�U�x�xt�Tvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/CollectionConstraint.php	Z%�U	��
 ��Jvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/Constraint.php�Z%�U�!�f��Svendor/justinrainbow/json-schema/src/JsonSchema/Constraints/ConstraintInterface.phpNZ%�UN��My�Nvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/EnumConstraint.phpOZ%�UO �"�Pvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/FormatConstraint.php�
Z%�U�
�'���Pvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/NumberConstraint.php�Z%�U�@��Pvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/ObjectConstraint.php�
 Z%�U�
 �.#�Pvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/SchemaConstraint.php Z%�U ����Pvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/StringConstraint.php�Z%�U�^�R�Nvendor/justinrainbow/json-schema/src/JsonSchema/Constraints/TypeConstraint.phpZ%�U����Svendor/justinrainbow/json-schema/src/JsonSchema/Constraints/UndefinedConstraint.php�Z%�U���׮�Vvendor/justinrainbow/json-schema/src/JsonSchema/Exception/InvalidArgumentException.phpvZ%�Uv� �"�]vendor/justinrainbow/json-schema/src/JsonSchema/Exception/InvalidSchemaMediaTypeException.phpvZ%�Uv�CӶWvendor/justinrainbow/json-schema/src/JsonSchema/Exception/InvalidSourceUriException.phpwZ%�UwN-�[�Svendor/justinrainbow/json-schema/src/JsonSchema/Exception/JsonDecodingException.php�Z%�U������Wvendor/justinrainbow/json-schema/src/JsonSchema/Exception/ResourceNotFoundException.phpoZ%�Uo�$"ŶRvendor/justinrainbow/json-schema/src/JsonSchema/Exception/UriResolverException.phpjZ%�UjS�ǳ�?vendor/justinrainbow/json-schema/src/JsonSchema/RefResolver.php�
 Z%�U�
 �
 ��Tvendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/AbstractRetriever.php�Z%�U�]j�Gvendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/Curl.phptZ%�UtI���Rvendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/FileGetContents.phpbZ%�UbW���Rvendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/PredefinedArray.php*Z%�U*-3��Xvendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/UriRetrieverInterface.php�Z%�U�CO�Cvendor/justinrainbow/json-schema/src/JsonSchema/Uri/UriResolver.phpR	Z%�UR	p�i1�Dvendor/justinrainbow/json-schema/src/JsonSchema/Uri/UriRetriever.phpaZ%�Ua�,Η�=vendor/justinrainbow/json-schema/src/JsonSchema/Validator.php�Z%�U�,u¶%vendor/composer/spdx-licenses/LICENSEZ%�UBh�2vendor/composer/spdx-licenses/src/SpdxLicenses.php
Z%�U
@p҄�vendor/autoload.php�Z%�U��^,�'vendor/composer/autoload_namespaces.php�Z%�U�[��!vendor/composer/autoload_psr4.php�Z%�U�TJJ��%vendor/composer/autoload_classmap.phpdZ%�UdZ��H�!vendor/composer/autoload_real.php7Z%�U7�[��vendor/composer/ClassLoader.phpBZ%�UB���bin/composerlZ%�UlԚ�	�LICENSE3Z%�U3f��X�<?php











 namespace Composer\Autoload;

 use Composer\Config;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Installer\InstallationManager;
 use Composer\IO\IOInterface;
 use Composer\Package\AliasPackage;
 use Composer\Package\PackageInterface;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Util\Filesystem;
 use Composer\Script\ScriptEvents;





 class AutoloadGenerator
 {



 private $eventDispatcher;




 private $io;

 private $devMode = false;

 public function __construct(EventDispatcher $eventDispatcher, IOInterface $io = null)
 {
 $this->eventDispatcher = $eventDispatcher;
 $this->io = $io;
 }

 public function setDevMode($devMode = true)
 {
 $this->devMode = (boolean) $devMode;
 }

 public function dump(Config $config, InstalledRepositoryInterface $localRepo, PackageInterface $mainPackage, InstallationManager $installationManager, $targetDir, $scanPsr0Packages = false, $suffix = '')
 {
 $this->eventDispatcher->dispatchScript(ScriptEvents::PRE_AUTOLOAD_DUMP, $this->devMode, array(), array(
 'optimize' => (bool) $scanPsr0Packages,
 ));

 $filesystem = new Filesystem();
 $filesystem->ensureDirectoryExists($config->get('vendor-dir'));
 $basePath = $filesystem->normalizePath(realpath(getcwd()));
 $vendorPath = $filesystem->normalizePath(realpath($config->get('vendor-dir')));
 $useGlobalIncludePath = (bool) $config->get('use-include-path');
 $prependAutoloader = $config->get('prepend-autoloader') === false ? 'false' : 'true';
 $classMapAuthoritative = $config->get('classmap-authoritative');
 $targetDir = $vendorPath.'/'.$targetDir;
 $filesystem->ensureDirectoryExists($targetDir);

 $vendorPathCode = $filesystem->findShortestPathCode(realpath($targetDir), $vendorPath, true);
 $vendorPathCode52 = str_replace('__DIR__', 'dirname(__FILE__)', $vendorPathCode);
 $vendorPathToTargetDirCode = $filesystem->findShortestPathCode($vendorPath, realpath($targetDir), true);

 $appBaseDirCode = $filesystem->findShortestPathCode($vendorPath, $basePath, true);
 $appBaseDirCode = str_replace('__DIR__', '$vendorDir', $appBaseDirCode);

 $namespacesFile = <<<EOF
 <?php

 // autoload_namespaces.php @generated by Composer

 \$vendorDir = $vendorPathCode52;
 \$baseDir = $appBaseDirCode;

 return array(

 EOF;

 $psr4File = <<<EOF
 <?php

 // autoload_psr4.php @generated by Composer

 \$vendorDir = $vendorPathCode52;
 \$baseDir = $appBaseDirCode;

 return array(

 EOF;


 $packageMap = $this->buildPackageMap($installationManager, $mainPackage, $localRepo->getCanonicalPackages());
 $autoloads = $this->parseAutoloads($packageMap, $mainPackage);


 foreach ($autoloads['psr-0'] as $namespace => $paths) {
 $exportedPaths = array();
 foreach ($paths as $path) {
 $exportedPaths[] = $this->getPathCode($filesystem, $basePath, $vendorPath, $path);
 }
 $exportedPrefix = var_export($namespace, true);
 $namespacesFile .= "    $exportedPrefix => ";
 $namespacesFile .= "array(".implode(', ', $exportedPaths)."),\n";
 }
 $namespacesFile .= ");\n";


 foreach ($autoloads['psr-4'] as $namespace => $paths) {
 $exportedPaths = array();
 foreach ($paths as $path) {
 $exportedPaths[] = $this->getPathCode($filesystem, $basePath, $vendorPath, $path);
 }
 $exportedPrefix = var_export($namespace, true);
 $psr4File .= "    $exportedPrefix => ";
 $psr4File .= "array(".implode(', ', $exportedPaths)."),\n";
 }
 $psr4File .= ");\n";

 $classmapFile = <<<EOF
 <?php

 // autoload_classmap.php @generated by Composer

 \$vendorDir = $vendorPathCode52;
 \$baseDir = $appBaseDirCode;

 return array(

 EOF;


 $targetDirLoader = null;
 $mainAutoload = $mainPackage->getAutoload();
 if ($mainPackage->getTargetDir() && !empty($mainAutoload['psr-0'])) {
 $levels = count(explode('/', $filesystem->normalizePath($mainPackage->getTargetDir())));
 $prefixes = implode(', ', array_map(function ($prefix) {
 return var_export($prefix, true);
 }, array_keys($mainAutoload['psr-0'])));
 $baseDirFromTargetDirCode = $filesystem->findShortestPathCode($targetDir, $basePath, true);

 $targetDirLoader = <<<EOF

    public static function autoload(\$class)
    {
        \$dir = $baseDirFromTargetDirCode . '/';
        \$prefixes = array($prefixes);
        foreach (\$prefixes as \$prefix) {
            if (0 !== strpos(\$class, \$prefix)) {
                continue;
            }
            \$path = \$dir . implode('/', array_slice(explode('\\\\', \$class), $levels)).'.php';
            if (!\$path = stream_resolve_include_path(\$path)) {
                return false;
            }
            require \$path;

            return true;
        }
    }

 EOF;
 }


 $classMap = array();
 if ($scanPsr0Packages) {
 $namespacesToScan = array();


 foreach (array('psr-0', 'psr-4') as $psrType) {
 foreach ($autoloads[$psrType] as $namespace => $paths) {
 $namespacesToScan[$namespace][] = array('paths' => $paths, 'type' => $psrType);
 }
 }

 krsort($namespacesToScan);

 foreach ($namespacesToScan as $namespace => $groups) {
 foreach ($groups as $group) {
 $psrType = $group['type'];
 foreach ($group['paths'] as $dir) {
 $dir = $filesystem->normalizePath($filesystem->isAbsolutePath($dir) ? $dir : $basePath.'/'.$dir);
 if (!is_dir($dir)) {
 continue;
 }
 $whitelist = sprintf(
 '{%s/%s.+$}',
 preg_quote($dir),
 ($psrType === 'psr-0' && strpos($namespace, '_') === false) ? preg_quote(strtr($namespace, '\\', '/')) : ''
 );

 $namespaceFilter = $namespace === '' ? null : $namespace;
 foreach (ClassMapGenerator::createMap($dir, $whitelist, $this->io, $namespaceFilter) as $class => $path) {
 $pathCode = $this->getPathCode($filesystem, $basePath, $vendorPath, $path).",\n";
 if (!isset($classMap[$class])) {
 $classMap[$class] = $pathCode;
 } elseif ($this->io && $classMap[$class] !== $pathCode && !preg_match('{/(test|fixture|example|stub)s?/}i', strtr($classMap[$class].' '.$path, '\\', '/'))) {
 $this->io->writeError(
 '<warning>Warning: Ambiguous class resolution, "'.$class.'"'.
 ' was found in both "'.str_replace(array('$vendorDir . \'', "',\n"), array($vendorPath, ''), $classMap[$class]).'" and "'.$path.'", the first will be used.</warning>'
 );
 }
 }
 }
 }
 }
 }

 foreach ($autoloads['classmap'] as $dir) {
 foreach (ClassMapGenerator::createMap($dir, null, $this->io) as $class => $path) {
 $pathCode = $this->getPathCode($filesystem, $basePath, $vendorPath, $path).",\n";
 if (!isset($classMap[$class])) {
 $classMap[$class] = $pathCode;
 } elseif ($this->io && $classMap[$class] !== $pathCode && !preg_match('{/(test|fixture|example|stub)s?/}i', strtr($classMap[$class].' '.$path, '\\', '/'))) {
 $this->io->writeError(
 '<warning>Warning: Ambiguous class resolution, "'.$class.'"'.
 ' was found in both "'.str_replace(array('$vendorDir . \'', "',\n"), array($vendorPath, ''), $classMap[$class]).'" and "'.$path.'", the first will be used.</warning>'
 );
 }
 }
 }

 ksort($classMap);
 foreach ($classMap as $class => $code) {
 $classmapFile .= '    '.var_export($class, true).' => '.$code;
 }
 $classmapFile .= ");\n";

 if (!$suffix) {
 if (!$config->get('autoloader-suffix') && is_readable($vendorPath.'/autoload.php')) {
 $content = file_get_contents($vendorPath.'/autoload.php');
 if (preg_match('{ComposerAutoloaderInit([^:\s]+)::}', $content, $match)) {
 $suffix = $match[1];
 }
 }

 if (!$suffix) {
 $suffix = $config->get('autoloader-suffix') ?: md5(uniqid('', true));
 }
 }

 file_put_contents($targetDir.'/autoload_namespaces.php', $namespacesFile);
 file_put_contents($targetDir.'/autoload_psr4.php', $psr4File);
 file_put_contents($targetDir.'/autoload_classmap.php', $classmapFile);
 $includePathFilePath = $targetDir.'/include_paths.php';
 if ($includePathFileContents = $this->getIncludePathsFile($packageMap, $filesystem, $basePath, $vendorPath, $vendorPathCode52, $appBaseDirCode)) {
 file_put_contents($includePathFilePath, $includePathFileContents);
 } else if (file_exists($includePathFilePath)){
 unlink($includePathFilePath);
 }
 $includeFilesFilePath = $targetDir.'/autoload_files.php';
 if ($includeFilesFileContents = $this->getIncludeFilesFile($autoloads['files'], $filesystem, $basePath, $vendorPath, $vendorPathCode52, $appBaseDirCode)) {
 file_put_contents($includeFilesFilePath, $includeFilesFileContents);
 } else if (file_exists($includeFilesFilePath)) {
 unlink($includeFilesFilePath);
 }
 file_put_contents($vendorPath.'/autoload.php', $this->getAutoloadFile($vendorPathToTargetDirCode, $suffix));
 file_put_contents($targetDir.'/autoload_real.php', $this->getAutoloadRealFile(true, (bool) $includePathFileContents, $targetDirLoader, (bool) $includeFilesFileContents, $vendorPathCode, $appBaseDirCode, $suffix, $useGlobalIncludePath, $prependAutoloader, $classMapAuthoritative));

 $this->safeCopy(__DIR__.'/ClassLoader.php', $targetDir.'/ClassLoader.php');
 $this->safeCopy(__DIR__.'/../../../LICENSE', $targetDir.'/LICENSE');

 $this->eventDispatcher->dispatchScript(ScriptEvents::POST_AUTOLOAD_DUMP, $this->devMode, array(), array(
 'optimize' => (bool) $scanPsr0Packages,
 ));
 }

 public function buildPackageMap(InstallationManager $installationManager, PackageInterface $mainPackage, array $packages)
 {

 $packageMap = array(array($mainPackage, ''));

 foreach ($packages as $package) {
 if ($package instanceof AliasPackage) {
 continue;
 }
 $this->validatePackage($package);

 $packageMap[] = array(
 $package,
 $installationManager->getInstallPath($package),
 );
 }

 return $packageMap;
 }






 protected function validatePackage(PackageInterface $package)
 {
 $autoload = $package->getAutoload();
 if (!empty($autoload['psr-4']) && null !== $package->getTargetDir()) {
 $name = $package->getName();
 $package->getTargetDir();
 throw new \InvalidArgumentException("PSR-4 autoloading is incompatible with the target-dir property, remove the target-dir in package '$name'.");
 }
 if (!empty($autoload['psr-4'])) {
 foreach ($autoload['psr-4'] as $namespace => $dirs) {
 if ($namespace !== '' && '\\' !== substr($namespace, -1)) {
 throw new \InvalidArgumentException("psr-4 namespaces must end with a namespace separator, '$namespace' does not, use '$namespace\\'.");
 }
 }
 }
 }








 public function parseAutoloads(array $packageMap, PackageInterface $mainPackage)
 {
 $mainPackageMap = array_shift($packageMap);
 $sortedPackageMap = $this->sortPackageMap($packageMap);
 $sortedPackageMap[] = $mainPackageMap;
 array_unshift($packageMap, $mainPackageMap);

 $psr0 = $this->parseAutoloadsType($packageMap, 'psr-0', $mainPackage);
 $psr4 = $this->parseAutoloadsType($packageMap, 'psr-4', $mainPackage);
 $classmap = $this->parseAutoloadsType(array_reverse($sortedPackageMap), 'classmap', $mainPackage);
 $files = $this->parseAutoloadsType($sortedPackageMap, 'files', $mainPackage);

 krsort($psr0);
 krsort($psr4);

 return array('psr-0' => $psr0, 'psr-4' => $psr4, 'classmap' => $classmap, 'files' => $files);
 }







 public function createLoader(array $autoloads)
 {
 $loader = new ClassLoader();

 if (isset($autoloads['psr-0'])) {
 foreach ($autoloads['psr-0'] as $namespace => $path) {
 $loader->add($namespace, $path);
 }
 }

 if (isset($autoloads['psr-4'])) {
 foreach ($autoloads['psr-4'] as $namespace => $path) {
 $loader->addPsr4($namespace, $path);
 }
 }

 return $loader;
 }

 protected function getIncludePathsFile(array $packageMap, Filesystem $filesystem, $basePath, $vendorPath, $vendorPathCode, $appBaseDirCode)
 {
 $includePaths = array();

 foreach ($packageMap as $item) {
 list($package, $installPath) = $item;

 if (null !== $package->getTargetDir() && strlen($package->getTargetDir()) > 0) {
 $installPath = substr($installPath, 0, -strlen('/'.$package->getTargetDir()));
 }

 foreach ($package->getIncludePaths() as $includePath) {
 $includePath = trim($includePath, '/');
 $includePaths[] = empty($installPath) ? $includePath : $installPath.'/'.$includePath;
 }
 }

 if (!$includePaths) {
 return;
 }

 $includePathsCode = '';
 foreach ($includePaths as $path) {
 $includePathsCode .= "    " . $this->getPathCode($filesystem, $basePath, $vendorPath, $path) . ",\n";
 }

 return <<<EOF
 <?php

 // include_paths.php @generated by Composer

 \$vendorDir = $vendorPathCode;
 \$baseDir = $appBaseDirCode;

 return array(
 $includePathsCode);

 EOF;
 }

 protected function getIncludeFilesFile(array $files, Filesystem $filesystem, $basePath, $vendorPath, $vendorPathCode, $appBaseDirCode)
 {
 $filesCode = '';
 foreach ($files as $functionFile) {
 $filesCode .= '    '.$this->getPathCode($filesystem, $basePath, $vendorPath, $functionFile).",\n";
 }

 if (!$filesCode) {
 return false;
 }

 return <<<EOF
 <?php

 // autoload_files.php @generated by Composer

 \$vendorDir = $vendorPathCode;
 \$baseDir = $appBaseDirCode;

 return array(
 $filesCode);

 EOF;
 }

 protected function getPathCode(Filesystem $filesystem, $basePath, $vendorPath, $path)
 {
 if (!$filesystem->isAbsolutePath($path)) {
 $path = $basePath . '/' . $path;
 }
 $path = $filesystem->normalizePath($path);

 $baseDir = '';
 if (strpos($path.'/', $vendorPath.'/') === 0) {
 $path = substr($path, strlen($vendorPath));
 $baseDir = '$vendorDir';

 if ($path !== false) {
 $baseDir .= " . ";
 }
 } else {
 $path = $filesystem->normalizePath($filesystem->findShortestPath($basePath, $path, true));
 if (!$filesystem->isAbsolutePath($path)) {
 $baseDir = '$baseDir . ';
 $path = '/' . $path;
 }
 }

 if (preg_match('/\.phar$/', $path)) {
 $baseDir = "'phar://' . " . $baseDir;
 }

 return $baseDir . (($path !== false) ? var_export($path, true) : "");
 }

 protected function getAutoloadFile($vendorPathToTargetDirCode, $suffix)
 {
 return <<<AUTOLOAD
 <?php

 // autoload.php @generated by Composer

 require_once $vendorPathToTargetDirCode . '/autoload_real.php';

 return ComposerAutoloaderInit$suffix::getLoader();

 AUTOLOAD;
 }

 protected function getAutoloadRealFile($useClassMap, $useIncludePath, $targetDirLoader, $useIncludeFiles, $vendorPathCode, $appBaseDirCode, $suffix, $useGlobalIncludePath, $prependAutoloader, $classMapAuthoritative)
 {

 
 
 
 
 

 $file = <<<HEADER
 <?php

 // autoload_real.php @generated by Composer

 class ComposerAutoloaderInit$suffix
 {
    private static \$loader;

    public static function loadClassLoader(\$class)
    {
        if ('Composer\\Autoload\\ClassLoader' === \$class) {
            require __DIR__ . '/ClassLoader.php';
        }
    }

    public static function getLoader()
    {
        if (null !== self::\$loader) {
            return self::\$loader;
        }

        spl_autoload_register(array('ComposerAutoloaderInit$suffix', 'loadClassLoader'), true, $prependAutoloader);
        self::\$loader = \$loader = new \\Composer\\Autoload\\ClassLoader();
        spl_autoload_unregister(array('ComposerAutoloaderInit$suffix', 'loadClassLoader'));


 HEADER;

 if ($useIncludePath) {
 $file .= <<<'INCLUDE_PATH'
        $includePaths = require __DIR__ . '/include_paths.php';
        array_push($includePaths, get_include_path());
        set_include_path(join(PATH_SEPARATOR, $includePaths));


 INCLUDE_PATH;
 }

 $file .= <<<'PSR0'
        $map = require __DIR__ . '/autoload_namespaces.php';
        foreach ($map as $namespace => $path) {
            $loader->set($namespace, $path);
        }


 PSR0;

 $file .= <<<'PSR4'
        $map = require __DIR__ . '/autoload_psr4.php';
        foreach ($map as $namespace => $path) {
            $loader->setPsr4($namespace, $path);
        }


 PSR4;

 if ($useClassMap) {
 $file .= <<<'CLASSMAP'
        $classMap = require __DIR__ . '/autoload_classmap.php';
        if ($classMap) {
            $loader->addClassMap($classMap);
        }


 CLASSMAP;
 }

 if ($classMapAuthoritative) {
 $file .= <<<'CLASSMAPAUTHORITATIVE'
        $loader->setClassMapAuthoritative(true);

 CLASSMAPAUTHORITATIVE;
 }

 if ($useGlobalIncludePath) {
 $file .= <<<'INCLUDEPATH'
        $loader->setUseIncludePath(true);

 INCLUDEPATH;
 }

 if ($targetDirLoader) {
 $file .= <<<REGISTER_AUTOLOAD
        spl_autoload_register(array('ComposerAutoloaderInit$suffix', 'autoload'), true, true);


 REGISTER_AUTOLOAD;
 }

 $file .= <<<REGISTER_LOADER
        \$loader->register($prependAutoloader);


 REGISTER_LOADER;

 if ($useIncludeFiles) {
 $file .= <<<INCLUDE_FILES
        \$includeFiles = require __DIR__ . '/autoload_files.php';
        foreach (\$includeFiles as \$file) {
            composerRequire$suffix(\$file);
        }


 INCLUDE_FILES;
 }

 $file .= <<<METHOD_FOOTER
        return \$loader;
    }

 METHOD_FOOTER;

 $file .= $targetDirLoader;

 return $file . <<<FOOTER
 }

 function composerRequire$suffix(\$file)
 {
    require \$file;
 }

 FOOTER;
 }

 protected function parseAutoloadsType(array $packageMap, $type, PackageInterface $mainPackage)
 {
 $autoloads = array();

 foreach ($packageMap as $item) {
 list($package, $installPath) = $item;

 $autoload = $package->getAutoload();
 if ($this->devMode && $package === $mainPackage) {
 $autoload = array_merge_recursive($autoload, $package->getDevAutoload());
 }


 if (!isset($autoload[$type]) || !is_array($autoload[$type])) {
 continue;
 }
 if (null !== $package->getTargetDir() && $package !== $mainPackage) {
 $installPath = substr($installPath, 0, -strlen('/'.$package->getTargetDir()));
 }

 foreach ($autoload[$type] as $namespace => $paths) {
 foreach ((array) $paths as $path) {
 if (($type === 'files' || $type === 'classmap') && $package->getTargetDir() && !is_readable($installPath.'/'.$path)) {

 if ($package === $mainPackage) {
 $targetDir = str_replace('\\<dirsep\\>', '[\\\\/]', preg_quote(str_replace(array('/', '\\'), '<dirsep>', $package->getTargetDir())));
 $path = ltrim(preg_replace('{^'.$targetDir.'}', '', ltrim($path, '\\/')), '\\/');
 } else {

 $path = $package->getTargetDir() . '/' . $path;
 }
 }

 $relativePath = empty($installPath) ? (empty($path) ? '.' : $path) : $installPath.'/'.$path;

 if ($type === 'files' || $type === 'classmap') {
 $autoloads[] = $relativePath;
 continue;
 }

 $autoloads[$namespace][] = $relativePath;
 }
 }
 }

 return $autoloads;
 }









 protected function sortPackageMap(array $packageMap)
 {
 $packages = array();
 $paths = array();
 $usageList = array();

 foreach ($packageMap as $item) {
 list($package, $path) = $item;
 $name = $package->getName();
 $packages[$name] = $package;
 $paths[$name] = $path;

 foreach (array_merge($package->getRequires(), $package->getDevRequires()) as $link) {
 $target = $link->getTarget();
 $usageList[$target][] = $name;
 }
 }

 $computing = array();
 $computed = array();
 $computeImportance = function ($name) use (&$computeImportance, &$computing, &$computed, $usageList) {

 if (isset($computed[$name])) {
 return $computed[$name];
 }


 if (isset($computing[$name])) {
 return 0;
 }

 $computing[$name] = true;
 $weight = 0;

 if (isset($usageList[$name])) {
 foreach ($usageList[$name] as $user) {
 $weight -= 1 - $computeImportance($user);
 }
 }

 unset($computing[$name]);
 $computed[$name] = $weight;

 return $weight;
 };

 $weightList = array();

 foreach ($packages as $name => $package) {
 $weight = $computeImportance($name);
 $weightList[$name] = $weight;
 }

 $stable_sort = function (&$array) {
 static $transform, $restore;

 $i = 0;

 if (!$transform) {
 $transform = function (&$v, $k) use (&$i) {
 $v = array($v, ++$i, $k, $v);
 };

 $restore = function (&$v, $k) {
 $v = $v[3];
 };
 }

 array_walk($array, $transform);
 asort($array);
 array_walk($array, $restore);
 };

 $stable_sort($weightList);

 $sortedPackageMap = array();

 foreach (array_keys($weightList) as $name) {
 $sortedPackageMap[] = array($packages[$name], $paths[$name]);
 }

 return $sortedPackageMap;
 }







 protected function safeCopy($source, $target)
 {
 $source = fopen($source, 'r');
 $target = fopen($target, 'w+');

 stream_copy_to_stream($source, $target);
 fclose($source);
 fclose($target);
 }
 }
 <?php












 namespace Composer\Autoload;

 use Symfony\Component\Finder\Finder;
 use Composer\IO\IOInterface;







 class ClassMapGenerator
 {






 public static function dump($dirs, $file)
 {
 $maps = array();

 foreach ($dirs as $dir) {
 $maps = array_merge($maps, static::createMap($dir));
 }

 file_put_contents($file, sprintf('<?php return %s;', var_export($maps, true)));
 }













 public static function createMap($path, $whitelist = null, IOInterface $io = null, $namespace = null)
 {
 if (is_string($path)) {
 if (is_file($path)) {
 $path = array(new \SplFileInfo($path));
 } elseif (is_dir($path)) {
 $path = Finder::create()->files()->followLinks()->name('/\.(php|inc|hh)$/')->in($path);
 } else {
 throw new \RuntimeException(
 'Could not scan for classes inside "'.$path.
 '" which does not appear to be a file nor a folder'
 );
 }
 }

 $map = array();

 foreach ($path as $file) {
 $filePath = $file->getRealPath();

 if (!in_array(pathinfo($filePath, PATHINFO_EXTENSION), array('php', 'inc', 'hh'))) {
 continue;
 }

 if ($whitelist && !preg_match($whitelist, strtr($filePath, '\\', '/'))) {
 continue;
 }

 $classes = self::findClasses($filePath);

 foreach ($classes as $class) {

 if (null !== $namespace && 0 !== strpos($class, $namespace)) {
 continue;
 }

 if (!isset($map[$class])) {
 $map[$class] = $filePath;
 } elseif ($io && $map[$class] !== $filePath && !preg_match('{/(test|fixture|example|stub)s?/}i', strtr($map[$class].' '.$filePath, '\\', '/'))) {
 $io->writeError(
 '<warning>Warning: Ambiguous class resolution, "'.$class.'"'.
 ' was found in both "'.$map[$class].'" and "'.$filePath.'", the first will be used.</warning>'
 );
 }
 }
 }

 return $map;
 }








 private static function findClasses($path)
 {
 $extraTypes = PHP_VERSION_ID < 50400 ? '' : '|trait';
 if (defined('HHVM_VERSION') && version_compare(HHVM_VERSION, '3.3', '>=')) {
 $extraTypes .= '|enum';
 }

 try {
 $contents = @php_strip_whitespace($path);
 if (!$contents) {
 if (!file_exists($path)) {
 throw new \Exception('File does not exist');
 }
 if (!is_readable($path)) {
 throw new \Exception('File is not readable');
 }
 }
 } catch (\Exception $e) {
 throw new \RuntimeException('Could not scan for classes inside '.$path.": \n".$e->getMessage(), 0, $e);
 }


 if (!preg_match('{\b(?:class|interface'.$extraTypes.')\s}i', $contents)) {
 return array();
 }


 $contents = preg_replace('{<<<\s*(\'?)(\w+)\\1(?:\r\n|\n|\r)(?:.*?)(?:\r\n|\n|\r)\\2(?=\r\n|\n|\r|;)}s', 'null', $contents);

 $contents = preg_replace('{"[^"\\\\]*+(\\\\.[^"\\\\]*+)*+"|\'[^\'\\\\]*+(\\\\.[^\'\\\\]*+)*+\'}s', 'null', $contents);

 if (substr($contents, 0, 2) !== '<?') {
 $contents = preg_replace('{^.+?<\?}s', '<?', $contents, 1, $replacements);
 if ($replacements === 0) {
 return array();
 }
 }

 $contents = preg_replace('{\?>.+<\?}s', '?><?', $contents);

 $pos = strrpos($contents, '?>');
 if (false !== $pos && false === strpos(substr($contents, $pos), '<?')) {
 $contents = substr($contents, 0, $pos);
 }

 preg_match_all('{
            (?:
                 \b(?<![\$:>])(?P<type>class|interface'.$extraTypes.') \s++ (?P<name>[a-zA-Z_\x7f-\xff:][a-zA-Z0-9_\x7f-\xff:\-]*+)
               | \b(?<![\$:>])(?P<ns>namespace) (?P<nsname>\s++[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\s*+\\\\\s*+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+)*+)? \s*+ [\{;]
            )
        }ix', $contents, $matches);

 $classes = array();
 $namespace = '';

 for ($i = 0, $len = count($matches['type']); $i < $len; $i++) {
 if (!empty($matches['ns'][$i])) {
 $namespace = str_replace(array(' ', "\t", "\r", "\n"), '', $matches['nsname'][$i]) . '\\';
 } else {
 $name = $matches['name'][$i];
 if ($name[0] === ':') {

 $name = 'xhp'.substr(str_replace(array('-', ':'), array('_', '__'), $name), 1);
 } elseif ($matches['type'][$i] === 'enum') {

 
 
 
 $name = rtrim($name, ':');
 }
 $classes[] = ltrim($namespace . $name, '\\');
 }
 }

 return $classes;
 }
 }
 <?php











 namespace Composer;

 use Composer\IO\IOInterface;
 use Composer\Util\Filesystem;
 use Symfony\Component\Finder\Finder;






 class Cache
 {
 private static $cacheCollected = false;
 private $io;
 private $root;
 private $enabled = true;
 private $whitelist;
 private $filesystem;







 public function __construct(IOInterface $io, $cacheDir, $whitelist = 'a-z0-9.', Filesystem $filesystem = null)
 {
 $this->io = $io;
 $this->root = rtrim($cacheDir, '/\\') . '/';
 $this->whitelist = $whitelist;
 $this->filesystem = $filesystem ?: new Filesystem();

 if (
 (!is_dir($this->root) && !@mkdir($this->root, 0777, true))
 || !is_writable($this->root)
 ) {
 $this->io->writeError('<warning>Cannot create cache directory ' . $this->root . ', or directory is not writable. Proceeding without cache</warning>');
 $this->enabled = false;
 }
 }

 public function isEnabled()
 {
 return $this->enabled;
 }

 public function getRoot()
 {
 return $this->root;
 }

 public function read($file)
 {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 if ($this->enabled && file_exists($this->root . $file)) {
 if ($this->io->isDebug()) {
 $this->io->writeError('Reading '.$this->root . $file.' from cache');
 }

 return file_get_contents($this->root . $file);
 }

 return false;
 }

 public function write($file, $contents)
 {
 if ($this->enabled) {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);

 if ($this->io->isDebug()) {
 $this->io->writeError('Writing '.$this->root . $file.' into cache');
 }

 try {
 return file_put_contents($this->root . $file, $contents);
 } catch (\ErrorException $e) {
 if ($this->io->isDebug()) {
 $this->io->writeError('<warning>Failed to write into cache: '.$e->getMessage().'</warning>');
 }
 if (preg_match('{^file_put_contents\(\): Only ([0-9]+) of ([0-9]+) bytes written}', $e->getMessage(), $m)) {

 unlink($this->root . $file);

 $message = sprintf(
 '<warning>Writing %1$s into cache failed after %2$u of %3$u bytes written, only %4$u bytes of free space available</warning>',
 $this->root . $file,
 $m[1],
 $m[2],
 @disk_free_space($this->root . dirname($file))
 );

 $this->io->writeError($message);

 return false;
 }

 throw $e;
 }
 }

 return false;
 }




 public function copyFrom($file, $source)
 {
 if ($this->enabled) {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 $this->filesystem->ensureDirectoryExists(dirname($this->root . $file));

 if ($this->io->isDebug()) {
 $this->io->writeError('Writing '.$this->root . $file.' into cache');
 }

 return copy($source, $this->root . $file);
 }

 return false;
 }




 public function copyTo($file, $target)
 {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 if ($this->enabled && file_exists($this->root . $file)) {
 try {
 touch($this->root . $file, filemtime($this->root . $file), time());
 } catch (\ErrorException $e) {

 
 touch($this->root . $file);
 }

 if ($this->io->isDebug()) {
 $this->io->writeError('Reading '.$this->root . $file.' from cache');
 }

 return copy($this->root . $file, $target);
 }

 return false;
 }

 public function gcIsNecessary()
 {
 return (!self::$cacheCollected && !mt_rand(0, 50));
 }

 public function remove($file)
 {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 if ($this->enabled && file_exists($this->root . $file)) {
 return $this->filesystem->unlink($this->root . $file);
 }

 return false;
 }

 public function gc($ttl, $maxSize)
 {
 if ($this->enabled) {
 $expire = new \DateTime();
 $expire->modify('-'.$ttl.' seconds');

 $finder = $this->getFinder()->date('until '.$expire->format('Y-m-d H:i:s'));
 foreach ($finder as $file) {
 $this->filesystem->unlink($file->getPathname());
 }

 $totalSize = $this->filesystem->size($this->root);
 if ($totalSize > $maxSize) {
 $iterator = $this->getFinder()->sortByAccessedTime()->getIterator();
 while ($totalSize > $maxSize && $iterator->valid()) {
 $filepath = $iterator->current()->getPathname();
 $totalSize -= $this->filesystem->size($filepath);
 $this->filesystem->unlink($filepath);
 $iterator->next();
 }
 }

 self::$cacheCollected = true;

 return true;
 }

 return false;
 }

 public function sha1($file)
 {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 if ($this->enabled && file_exists($this->root . $file)) {
 return sha1_file($this->root . $file);
 }

 return false;
 }

 public function sha256($file)
 {
 $file = preg_replace('{[^'.$this->whitelist.']}i', '-', $file);
 if ($this->enabled && file_exists($this->root . $file)) {
 return hash_file('sha256', $this->root . $file);
 }

 return false;
 }

 protected function getFinder()
 {
 return Finder::create()->in($this->root)->files();
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;




 class AboutCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('about')
 ->setDescription('Short information about Composer')
 ->setHelp(<<<EOT
 <info>php composer.phar about</info>
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $this->getIO()->write(<<<EOT
 <info>Composer - Package Management for PHP</info>
 <comment>Composer is a dependency manager tracking local dependencies of your projects and libraries.
 See https://getcomposer.org/ for more information.</comment>
 EOT
 );
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Factory;
 use Composer\IO\IOInterface;
 use Composer\Config;
 use Composer\Repository\CompositeRepository;
 use Composer\Script\ScriptEvents;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;

 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;






 class ArchiveCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('archive')
 ->setDescription('Create an archive of this composer package')
 ->setDefinition(array(
 new InputArgument('package', InputArgument::OPTIONAL, 'The package to archive instead of the current project'),
 new InputArgument('version', InputArgument::OPTIONAL, 'A version constraint to find the package to archive'),
 new InputOption('format', 'f', InputOption::VALUE_OPTIONAL, 'Format of the resulting archive: tar or zip'),
 new InputOption('dir', false, InputOption::VALUE_OPTIONAL, 'Write the archive to this directory'),
 ))
 ->setHelp(<<<EOT
 The <info>archive</info> command creates an archive of the specified format
 containing the files and directories of the Composer project or the specified
 package in the specified version and writes it to the specified directory.

 <info>php composer.phar archive [--format=zip] [--dir=/foo] [package [version]]</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $config = Factory::createConfig();
 $composer = $this->getComposer(false);
 if ($composer) {
 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'archive', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::PRE_ARCHIVE_CMD);
 }

 if (null === $input->getOption('format')) {
 $input->setOption('format', $config->get('archive-format'));
 }
 if (null === $input->getOption('dir')) {
 $input->setOption('dir', $config->get('archive-dir'));
 }

 $returnCode = $this->archive(
 $this->getIO(),
 $config,
 $input->getArgument('package'),
 $input->getArgument('version'),
 $input->getOption('format'),
 $input->getOption('dir')
 );

 if (0 === $returnCode && $composer) {
 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_ARCHIVE_CMD);
 }

 return $returnCode;
 }

 protected function archive(IOInterface $io, Config $config, $packageName = null, $version = null, $format = 'tar', $dest = '.')
 {
 $factory = new Factory;
 $downloadManager = $factory->createDownloadManager($io, $config);
 $archiveManager = $factory->createArchiveManager($config, $downloadManager);

 if ($packageName) {
 $package = $this->selectPackage($io, $packageName, $version);

 if (!$package) {
 return 1;
 }
 } else {
 $package = $this->getComposer()->getPackage();
 }

 $io->writeError('<info>Creating the archive into "'.$dest.'".</info>');
 $archiveManager->archive($package, $format, $dest);

 return 0;
 }

 protected function selectPackage(IOInterface $io, $packageName, $version = null)
 {
 $io->writeError('<info>Searching for the specified package.</info>');

 if ($composer = $this->getComposer(false)) {
 $localRepo = $composer->getRepositoryManager()->getLocalRepository();
 $repo = new CompositeRepository(array_merge(array($localRepo), $composer->getRepositoryManager()->getRepositories()));
 } else {
 $defaultRepos = Factory::createDefaultRepositories($this->getIO());
 $io->writeError('No composer.json found in the current directory, searching packages from ' . implode(', ', array_keys($defaultRepos)));
 $repo = new CompositeRepository($defaultRepos);
 }

 $packages = $repo->findPackages($packageName, $version);

 if (count($packages) > 1) {
 $package = reset($packages);
 $io->writeError('<info>Found multiple matches, selected '.$package->getPrettyString().'.</info>');
 $io->writeError('Alternatives were '.implode(', ', array_map(function ($p) { return $p->getPrettyString(); }, $packages)).'.');
 $io->writeError('<comment>Please use a more specific constraint to pick a different package.</comment>');
 } elseif ($packages) {
 $package = reset($packages);
 $io->writeError('<info>Found an exact match '.$package->getPrettyString().'.</info>');
 } else {
 $io->writeError('<error>Could not find a package matching '.$packageName.'.</error>');

 return false;
 }

 return $package;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Cache;
 use Composer\Factory;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;




 class ClearCacheCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('clear-cache')
 ->setAliases(array('clearcache'))
 ->setDescription('Clears composer\'s internal package cache.')
 ->setHelp(<<<EOT
 The <info>clear-cache</info> deletes all cached packages from composer's
 cache directory.
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $config = Factory::createConfig();
 $io = $this->getIO();

 $cachePaths = array(
 'cache-dir' => $config->get('cache-dir'),
 'cache-files-dir' => $config->get('cache-files-dir'),
 'cache-repo-dir' => $config->get('cache-repo-dir'),
 'cache-vcs-dir' => $config->get('cache-vcs-dir'),
 );

 foreach ($cachePaths as $key => $cachePath) {
 $cachePath = realpath($cachePath);
 if (!$cachePath) {
 $io->writeError("<info>Cache directory does not exist ($key): $cachePath</info>");

 continue;
 }
 $cache = new Cache($io, $cachePath);
 if (!$cache->isEnabled()) {
 $io->writeError("<info>Cache is not enabled ($key): $cachePath</info>");

 continue;
 }

 $io->writeError("<info>Clearing cache ($key): $cachePath</info>");
 $cache->gc(0, 0);
 }

 $io->writeError('<info>All caches cleared.</info>');
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Composer;
 use Composer\Console\Application;
 use Composer\IO\IOInterface;
 use Composer\IO\NullIO;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Command\Command as BaseCommand;







 abstract class Command extends BaseCommand
 {



 private $composer;




 private $io;







 public function getComposer($required = true, $disablePlugins = false)
 {
 if (null === $this->composer) {
 $application = $this->getApplication();
 if ($application instanceof Application) {

 $this->composer = $application->getComposer($required, $disablePlugins);
 } elseif ($required) {
 throw new \RuntimeException(
 'Could not create a Composer\Composer instance, you must inject '.
 'one if this command is not used with a Composer\Console\Application instance'
 );
 }
 }

 return $this->composer;
 }




 public function setComposer(Composer $composer)
 {
 $this->composer = $composer;
 }




 public function resetComposer()
 {
 $this->composer = null;
 $this->getApplication()->resetComposer();
 }




 public function getIO()
 {
 if (null === $this->io) {
 $application = $this->getApplication();
 if ($application instanceof Application) {

 $this->io = $application->getIO();
 } else {
 $this->io = new NullIO();
 }
 }

 return $this->io;
 }




 public function setIO(IOInterface $io)
 {
 $this->io = $io;
 }




 protected function initialize(InputInterface $input, OutputInterface $output)
 {
 if (true === $input->hasParameterOption(array('--no-ansi')) && $input->hasOption('no-progress')) {
 $input->setOption('no-progress', true);
 }

 parent::initialize($input, $output);
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Composer\Config;
 use Composer\Config\JsonConfigSource;
 use Composer\Factory;
 use Composer\Json\JsonFile;





 class ConfigCommand extends Command
 {



 protected $config;




 protected $configFile;




 protected $configSource;




 protected $authConfigFile;




 protected $authConfigSource;




 protected function configure()
 {
 $this
 ->setName('config')
 ->setDescription('Set config options')
 ->setDefinition(array(
 new InputOption('global', 'g', InputOption::VALUE_NONE, 'Apply command to the global config file'),
 new InputOption('editor', 'e', InputOption::VALUE_NONE, 'Open editor'),
 new InputOption('auth', 'a', InputOption::VALUE_NONE, 'Affect auth config file (only used for --editor)'),
 new InputOption('unset', null, InputOption::VALUE_NONE, 'Unset the given setting-key'),
 new InputOption('list', 'l', InputOption::VALUE_NONE, 'List configuration settings'),
 new InputOption('file', 'f', InputOption::VALUE_REQUIRED, 'If you want to choose a different composer.json or config.json'),
 new InputOption('absolute', null, InputOption::VALUE_NONE, 'Returns absolute paths when fetching *-dir config values instead of relative'),
 new InputArgument('setting-key', null, 'Setting key'),
 new InputArgument('setting-value', InputArgument::IS_ARRAY, 'Setting value'),
 ))
 ->setHelp(<<<EOT
 This command allows you to edit some basic composer settings in either the
 local composer.json file or the global config.json file.

 To set a config setting:

    <comment>%command.full_name% bin-dir bin/</comment>

 To read a config setting:

    <comment>%command.full_name% bin-dir</comment>
    Outputs: <info>bin</info>

 To edit the global config.json file:

    <comment>%command.full_name% --global</comment>

 To add a repository:

    <comment>%command.full_name% repositories.foo vcs http://bar.com</comment>

 To remove a repository (repo is a short alias for repositories):

    <comment>%command.full_name% --unset repo.foo</comment>

 To disable packagist:

    <comment>%command.full_name% repo.packagist false</comment>

 You can alter repositories in the global config.json file by passing in the
 <info>--global</info> option.

 To edit the file in an external editor:

    <comment>%command.full_name% --editor</comment>

 To choose your editor you can set the "EDITOR" env variable.

 To get a list of configuration values in the file:

    <comment>%command.full_name% --list</comment>

 You can always pass more than one option. As an example, if you want to edit the
 global config.json file.

    <comment>%command.full_name% --editor --global</comment>
 EOT
 )
 ;
 }




 protected function initialize(InputInterface $input, OutputInterface $output)
 {
 parent::initialize($input, $output);

 if ($input->getOption('global') && null !== $input->getOption('file')) {
 throw new \RuntimeException('--file and --global can not be combined');
 }

 $this->config = Factory::createConfig($this->getIO());


 
 $configFile = $input->getOption('global')
 ? ($this->config->get('home') . '/config.json')
 : ($input->getOption('file') ?: trim(getenv('COMPOSER')) ?: 'composer.json');


 if ($configFile === 'composer.json' && !file_exists($configFile) && realpath(getcwd()) === realpath($this->config->get('home'))) {
 file_put_contents($configFile, "{\n}\n");
 }

 $this->configFile = new JsonFile($configFile);
 $this->configSource = new JsonConfigSource($this->configFile);

 $authConfigFile = $input->getOption('global')
 ? ($this->config->get('home') . '/auth.json')
 : dirname(realpath($configFile)) . '/auth.json';

 $this->authConfigFile = new JsonFile($authConfigFile);
 $this->authConfigSource = new JsonConfigSource($this->authConfigFile, true);


 if ($input->getOption('global') && !$this->configFile->exists()) {
 touch($this->configFile->getPath());
 $this->configFile->write(array('config' => new \ArrayObject));
 @chmod($this->configFile->getPath(), 0600);
 }
 if ($input->getOption('global') && !$this->authConfigFile->exists()) {
 touch($this->authConfigFile->getPath());
 $this->authConfigFile->write(array('http-basic' => new \ArrayObject, 'github-oauth' => new \ArrayObject));
 @chmod($this->authConfigFile->getPath(), 0600);
 }

 if (!$this->configFile->exists()) {
 throw new \RuntimeException(sprintf('File "%s" cannot be found in the current directory', $configFile));
 }
 }




 protected function execute(InputInterface $input, OutputInterface $output)
 {

 if ($input->getOption('editor')) {
 $editor = escapeshellcmd(getenv('EDITOR'));
 if (!$editor) {
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $editor = 'notepad';
 } else {
 foreach (array('vim', 'vi', 'nano', 'pico', 'ed') as $candidate) {
 if (exec('which '.$candidate)) {
 $editor = $candidate;
 break;
 }
 }
 }
 }

 $file = $input->getOption('auth') ? $this->authConfigFile->getPath() : $this->configFile->getPath();
 system($editor . ' ' . $file . (defined('PHP_WINDOWS_VERSION_BUILD') ? '' : ' > `tty`'));

 return 0;
 }

 if (!$input->getOption('global')) {
 $this->config->merge($this->configFile->read());
 $this->config->merge(array('config' => $this->authConfigFile->exists() ? $this->authConfigFile->read() : array()));
 }


 if ($input->getOption('list')) {
 $this->listConfiguration($this->config->all(), $this->config->raw(), $output);

 return 0;
 }

 $settingKey = $input->getArgument('setting-key');
 if (!$settingKey) {
 return 0;
 }


 if (array() !== $input->getArgument('setting-value') && $input->getOption('unset')) {
 throw new \RuntimeException('You can not combine a setting value with --unset');
 }


 if (array() === $input->getArgument('setting-value') && !$input->getOption('unset')) {
 $data = $this->config->all();
 if (preg_match('/^repos?(?:itories)?(?:\.(.+))?/', $settingKey, $matches)) {
 if (empty($matches[1])) {
 $value = isset($data['repositories']) ? $data['repositories'] : array();
 } else {
 if (!isset($data['repositories'][$matches[1]])) {
 throw new \InvalidArgumentException('There is no '.$matches[1].' repository defined');
 }

 $value = $data['repositories'][$matches[1]];
 }
 } elseif (strpos($settingKey, '.')) {
 $bits = explode('.', $settingKey);
 $data = $data['config'];
 foreach ($bits as $bit) {
 if (isset($data[$bit])) {
 $data = $data[$bit];
 } elseif (isset($data[implode('.', $bits)])) {

 $data = $data[implode('.', $bits)];
 break;
 } else {
 throw new \RuntimeException($settingKey.' is not defined');
 }
 array_shift($bits);
 }

 $value = $data;
 } elseif (isset($data['config'][$settingKey])) {
 $value = $this->config->get($settingKey, $input->getOption('absolute') ? 0 : Config::RELATIVE_PATHS);
 } else {
 throw new \RuntimeException($settingKey.' is not defined');
 }

 if (is_array($value)) {
 $value = json_encode($value);
 }

 $this->getIO()->write($value);

 return 0;
 }

 $values = $input->getArgument('setting-value'); 

 $booleanValidator = function ($val) { return in_array($val, array('true', 'false', '1', '0'), true); };
 $booleanNormalizer = function ($val) { return $val !== 'false' && (bool) $val; };


 $uniqueConfigValues = array(
 'process-timeout' => array('is_numeric', 'intval'),
 'use-include-path' => array($booleanValidator, $booleanNormalizer),
 'preferred-install' => array(
 function ($val) { return in_array($val, array('auto', 'source', 'dist'), true); },
 function ($val) { return $val; }
 ),
 'store-auths' => array(
 function ($val) { return in_array($val, array('true', 'false', 'prompt'), true); },
 function ($val) {
 if ('prompt' === $val) {
 return 'prompt';
 }

 return $val !== 'false' && (bool) $val;
 }
 ),
 'notify-on-install' => array($booleanValidator, $booleanNormalizer),
 'vendor-dir' => array('is_string', function ($val) { return $val; }),
 'bin-dir' => array('is_string', function ($val) { return $val; }),
 'cache-dir' => array('is_string', function ($val) { return $val; }),
 'cache-files-dir' => array('is_string', function ($val) { return $val; }),
 'cache-repo-dir' => array('is_string', function ($val) { return $val; }),
 'cache-vcs-dir' => array('is_string', function ($val) { return $val; }),
 'cache-ttl' => array('is_numeric', 'intval'),
 'cache-files-ttl' => array('is_numeric', 'intval'),
 'cache-files-maxsize' => array(
 function ($val) { return preg_match('/^\s*([0-9.]+)\s*(?:([kmg])(?:i?b)?)?\s*$/i', $val) > 0; },
 function ($val) { return $val; }
 ),
 'discard-changes' => array(
 function ($val) { return in_array($val, array('stash', 'true', 'false', '1', '0'), true); },
 function ($val) {
 if ('stash' === $val) {
 return 'stash';
 }

 return $val !== 'false' && (bool) $val;
 }
 ),
 'autoloader-suffix' => array('is_string', function ($val) { return $val === 'null' ? null : $val; }),
 'optimize-autoloader' => array($booleanValidator, $booleanNormalizer),
 'classmap-authoritative' => array($booleanValidator, $booleanNormalizer),
 'prepend-autoloader' => array($booleanValidator, $booleanNormalizer),
 'github-expose-hostname' => array($booleanValidator, $booleanNormalizer),
 );
 $multiConfigValues = array(
 'github-protocols' => array(
 function ($vals) {
 if (!is_array($vals)) {
 return 'array expected';
 }

 foreach ($vals as $val) {
 if (!in_array($val, array('git', 'https', 'ssh'))) {
 return 'valid protocols include: git, https, ssh';
 }
 }

 return true;
 },
 function ($vals) {
 return $vals;
 }
 ),
 'github-domains' => array(
 function ($vals) {
 if (!is_array($vals)) {
 return 'array expected';
 }

 return true;
 },
 function ($vals) {
 return $vals;
 }
 ),
 );

 foreach ($uniqueConfigValues as $name => $callbacks) {
 if ($settingKey === $name) {
 if ($input->getOption('unset')) {
 return $this->configSource->removeConfigSetting($settingKey);
 }

 list($validator, $normalizer) = $callbacks;
 if (1 !== count($values)) {
 throw new \RuntimeException('You can only pass one value. Example: php composer.phar config process-timeout 300');
 }

 if (true !== $validation = $validator($values[0])) {
 throw new \RuntimeException(sprintf(
 '"%s" is an invalid value'.($validation ? ' ('.$validation.')' : ''),
 $values[0]
 ));
 }

 return $this->configSource->addConfigSetting($settingKey, $normalizer($values[0]));
 }
 }

 foreach ($multiConfigValues as $name => $callbacks) {
 if ($settingKey === $name) {
 if ($input->getOption('unset')) {
 return $this->configSource->removeConfigSetting($settingKey);
 }

 list($validator, $normalizer) = $callbacks;
 if (true !== $validation = $validator($values)) {
 throw new \RuntimeException(sprintf(
 '%s is an invalid value'.($validation ? ' ('.$validation.')' : ''),
 json_encode($values)
 ));
 }

 return $this->configSource->addConfigSetting($settingKey, $normalizer($values));
 }
 }


 if (preg_match('/^repos?(?:itories)?\.(.+)/', $settingKey, $matches)) {
 if ($input->getOption('unset')) {
 return $this->configSource->removeRepository($matches[1]);
 }

 if (2 === count($values)) {
 return $this->configSource->addRepository($matches[1], array(
 'type' => $values[0],
 'url' => $values[1],
 ));
 }

 if (1 === count($values)) {
 $bool = strtolower($values[0]);
 if (true === $booleanValidator($bool) && false === $booleanNormalizer($bool)) {
 return $this->configSource->addRepository($matches[1], false);
 }
 }

 throw new \RuntimeException('You must pass the type and a url. Example: php composer.phar config repositories.foo vcs http://bar.com');
 }


 if (preg_match('/^platform\.(.+)/', $settingKey, $matches)) {
 if ($input->getOption('unset')) {
 return $this->configSource->removeConfigSetting($settingKey);
 }

 return $this->configSource->addConfigSetting($settingKey, $values[0]);
 }


 if (preg_match('/^(github-oauth|http-basic)\.(.+)/', $settingKey, $matches)) {
 if ($input->getOption('unset')) {
 $this->authConfigSource->removeConfigSetting($matches[1].'.'.$matches[2]);
 $this->configSource->removeConfigSetting($matches[1].'.'.$matches[2]);

 return;
 }

 if ($matches[1] === 'github-oauth') {
 if (1 !== count($values)) {
 throw new \RuntimeException('Too many arguments, expected only one token');
 }
 $this->configSource->removeConfigSetting($matches[1].'.'.$matches[2]);
 $this->authConfigSource->addConfigSetting($matches[1].'.'.$matches[2], $values[0]);
 } elseif ($matches[1] === 'http-basic') {
 if (2 !== count($values)) {
 throw new \RuntimeException('Expected two arguments (username, password), got '.count($values));
 }
 $this->configSource->removeConfigSetting($matches[1].'.'.$matches[2]);
 $this->authConfigSource->addConfigSetting($matches[1].'.'.$matches[2], array('username' => $values[0], 'password' => $values[1]));
 }

 return;
 }

 throw new \InvalidArgumentException('Setting '.$settingKey.' does not exist or is not supported by this command');
 }









 protected function listConfiguration(array $contents, array $rawContents, OutputInterface $output, $k = null)
 {
 $origK = $k;
 foreach ($contents as $key => $value) {
 if ($k === null && !in_array($key, array('config', 'repositories'))) {
 continue;
 }

 $rawVal = isset($rawContents[$key]) ? $rawContents[$key] : null;

 if (is_array($value) && (!is_numeric(key($value)) || ($key === 'repositories' && null === $k))) {
 $k .= preg_replace('{^config\.}', '', $key . '.');
 $this->listConfiguration($value, $rawVal, $output, $k);

 if (substr_count($k, '.') > 1) {
 $k = str_split($k, strrpos($k, '.', -2));
 $k = $k[0] . '.';
 } else {
 $k = $origK;
 }

 continue;
 }

 if (is_array($value)) {
 $value = array_map(function ($val) {
 return is_array($val) ? json_encode($val) : $val;
 }, $value);

 $value = '['.implode(', ', $value).']';
 }

 if (is_bool($value)) {
 $value = var_export($value, true);
 }

 if (is_string($rawVal) && $rawVal != $value) {
 $this->getIO()->write('[<comment>' . $k . $key . '</comment>] <info>' . $rawVal . ' (' . $value . ')</info>');
 } else {
 $this->getIO()->write('[<comment>' . $k . $key . '</comment>] <info>' . $value . '</info>');
 }
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Config;
 use Composer\Factory;
 use Composer\Installer;
 use Composer\Installer\ProjectInstaller;
 use Composer\Installer\InstallationManager;
 use Composer\IO\IOInterface;
 use Composer\Package\BasePackage;
 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\Operation\InstallOperation;
 use Composer\Package\Version\VersionSelector;
 use Composer\Repository\ComposerRepository;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\FilesystemRepository;
 use Composer\Repository\InstalledFilesystemRepository;
 use Composer\Script\ScriptEvents;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Finder\Finder;
 use Composer\Json\JsonFile;
 use Composer\Config\JsonConfigSource;
 use Composer\Util\Filesystem;
 use Composer\Util\RemoteFilesystem;
 use Composer\Package\Version\VersionParser;









 class CreateProjectCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('create-project')
 ->setDescription('Create new project from a package into given directory.')
 ->setDefinition(array(
 new InputArgument('package', InputArgument::OPTIONAL, 'Package name to be installed'),
 new InputArgument('directory', InputArgument::OPTIONAL, 'Directory where the files should be created'),
 new InputArgument('version', InputArgument::OPTIONAL, 'Version, will default to latest'),
 new InputOption('stability', 's', InputOption::VALUE_REQUIRED, 'Minimum-stability allowed (unless a version is specified).'),
 new InputOption('prefer-source', null, InputOption::VALUE_NONE, 'Forces installation from package sources when possible, including VCS information.'),
 new InputOption('prefer-dist', null, InputOption::VALUE_NONE, 'Forces installation from package dist even for dev versions.'),
 new InputOption('repository-url', null, InputOption::VALUE_REQUIRED, 'Pick a different repository url to look for the package.'),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Enables installation of require-dev packages (enabled by default, only present for BC).'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables installation of require-dev packages.'),
 new InputOption('no-plugins', null, InputOption::VALUE_NONE, 'Whether to disable plugins.'),
 new InputOption('no-custom-installers', null, InputOption::VALUE_NONE, 'DEPRECATED: Use no-plugins instead.'),
 new InputOption('no-scripts', null, InputOption::VALUE_NONE, 'Whether to prevent execution of all defined scripts in the root package.'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 new InputOption('keep-vcs', null, InputOption::VALUE_NONE, 'Whether to prevent deletion vcs folder.'),
 new InputOption('no-install', null, InputOption::VALUE_NONE, 'Whether to skip installation of the package dependencies.'),
 new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
 ))
 ->setHelp(<<<EOT
 The <info>create-project</info> command creates a new project from a given
 package into a new directory. If executed without params and in a directory
 with a composer.json file it installs the packages for the current project.

 You can use this command to bootstrap new projects or setup a clean
 version-controlled installation for developers of your project.

 <info>php composer.phar create-project vendor/project target-directory [version]</info>

 You can also specify the version with the package name using = or : as separator.

 To install unstable packages, either specify the version you want, or use the
 --stability=dev (where dev can be one of RC, beta, alpha or dev).

 To setup a developer workable version you should create the project using the source
 controlled code by appending the <info>'--prefer-source'</info> flag.

 To install a package from another repository than the default one you
 can pass the <info>'--repository-url=http://myrepository.org'</info> flag.

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $config = Factory::createConfig();

 $this->updatePreferredOptions($config, $input, $preferSource, $preferDist, true);

 if ($input->getOption('no-custom-installers')) {
 $this->getIO()->writeError('<warning>You are using the deprecated option "no-custom-installers". Use "no-plugins" instead.</warning>');
 $input->setOption('no-plugins', true);
 }

 return $this->installProject(
 $this->getIO(),
 $config,
 $input->getArgument('package'),
 $input->getArgument('directory'),
 $input->getArgument('version'),
 $input->getOption('stability'),
 $preferSource,
 $preferDist,
 !$input->getOption('no-dev'),
 $input->getOption('repository-url'),
 $input->getOption('no-plugins'),
 $input->getOption('no-scripts'),
 $input->getOption('keep-vcs'),
 $input->getOption('no-progress'),
 $input->getOption('no-install'),
 $input->getOption('ignore-platform-reqs'),
 $input
 );
 }

 public function installProject(IOInterface $io, Config $config, $packageName, $directory = null, $packageVersion = null, $stability = 'stable', $preferSource = false, $preferDist = false, $installDevPackages = false, $repositoryUrl = null, $disablePlugins = false, $noScripts = false, $keepVcs = false, $noProgress = false, $noInstall = false, $ignorePlatformReqs = false, InputInterface $input)
 {
 $oldCwd = getcwd();


 $io->loadConfiguration($config);

 if ($packageName !== null) {
 $installedFromVcs = $this->installRootPackage($io, $config, $packageName, $directory, $packageVersion, $stability, $preferSource, $preferDist, $installDevPackages, $repositoryUrl, $disablePlugins, $noScripts, $keepVcs, $noProgress);
 } else {
 $installedFromVcs = false;
 }

 $composer = Factory::create($io, null, $disablePlugins);
 $composer->getDownloadManager()->setOutputProgress(!$noProgress);

 $fs = new Filesystem();

 if ($noScripts === false) {

 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_ROOT_PACKAGE_INSTALL, $installDevPackages);
 }

 $rootPackageConfig = $composer->getConfig();
 $this->updatePreferredOptions($rootPackageConfig, $input, $preferSource, $preferDist);


 if ($noInstall === false) {
 $installer = Installer::create($io, $composer);
 $installer->setPreferSource($preferSource)
 ->setPreferDist($preferDist)
 ->setDevMode($installDevPackages)
 ->setRunScripts(!$noScripts)
 ->setIgnorePlatformRequirements($ignorePlatformReqs);

 if ($disablePlugins) {
 $installer->disablePlugins();
 }

 $status = $installer->run();
 if (0 !== $status) {
 return $status;
 }
 }

 $hasVcs = $installedFromVcs;
 if (!$keepVcs && $installedFromVcs
 && (
 !$io->isInteractive()
 || $io->askConfirmation('<info>Do you want to remove the existing VCS (.git, .svn..) history?</info> [<comment>Y,n</comment>]? ', true)
 )
 ) {
 $finder = new Finder();
 $finder->depth(0)->directories()->in(getcwd())->ignoreVCS(false)->ignoreDotFiles(false);
 foreach (array('.svn', '_svn', 'CVS', '_darcs', '.arch-params', '.monotone', '.bzr', '.git', '.hg') as $vcsName) {
 $finder->name($vcsName);
 }

 try {
 $dirs = iterator_to_array($finder);
 unset($finder);
 foreach ($dirs as $dir) {
 if (!$fs->removeDirectory($dir)) {
 throw new \RuntimeException('Could not remove '.$dir);
 }
 }
 } catch (\Exception $e) {
 $io->writeError('<error>An error occurred while removing the VCS metadata: '.$e->getMessage().'</error>');
 }

 $hasVcs = false;
 }


 if (!$hasVcs) {
 $package = $composer->getPackage();
 $configSource = new JsonConfigSource(new JsonFile('composer.json'));
 foreach (BasePackage::$supportedLinkTypes as $type => $meta) {
 foreach ($package->{'get'.$meta['method']}() as $link) {
 if ($link->getPrettyConstraint() === 'self.version') {
 $configSource->addLink($type, $link->getTarget(), $package->getPrettyVersion());
 }
 }
 }
 }

 if ($noScripts === false) {

 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_CREATE_PROJECT_CMD, $installDevPackages);
 }

 chdir($oldCwd);
 $vendorComposerDir = $composer->getConfig()->get('vendor-dir').'/composer';
 if (is_dir($vendorComposerDir) && $fs->isDirEmpty($vendorComposerDir)) {
 @rmdir($vendorComposerDir);
 $vendorDir = $composer->getConfig()->get('vendor-dir');
 if (is_dir($vendorDir) && $fs->isDirEmpty($vendorDir)) {
 @rmdir($vendorDir);
 }
 }

 return 0;
 }

 protected function installRootPackage(IOInterface $io, Config $config, $packageName, $directory = null, $packageVersion = null, $stability = 'stable', $preferSource = false, $preferDist = false, $installDevPackages = false, $repositoryUrl = null, $disablePlugins = false, $noScripts = false, $keepVcs = false, $noProgress = false)
 {
 if (null === $repositoryUrl) {
 $sourceRepo = new CompositeRepository(Factory::createDefaultRepositories($io, $config));
 } elseif ("json" === pathinfo($repositoryUrl, PATHINFO_EXTENSION) && file_exists($repositoryUrl)) {
 $json = new JsonFile($repositoryUrl, new RemoteFilesystem($io, $config));
 $data = $json->read();
 if (!empty($data['packages']) || !empty($data['includes']) || !empty($data['provider-includes'])) {
 $sourceRepo = new ComposerRepository(array('url' => 'file://' . strtr(realpath($repositoryUrl), '\\', '/')), $io, $config);
 } else {
 $sourceRepo = new FilesystemRepository($json);
 }
 } elseif (0 === strpos($repositoryUrl, 'http')) {
 $sourceRepo = new ComposerRepository(array('url' => $repositoryUrl), $io, $config);
 } else {
 throw new \InvalidArgumentException("Invalid repository url given. Has to be a .json file or an http url.");
 }

 $parser = new VersionParser();
 $requirements = $parser->parseNameVersionPairs(array($packageName));
 $name = strtolower($requirements[0]['name']);
 if (!$packageVersion && isset($requirements[0]['version'])) {
 $packageVersion = $requirements[0]['version'];
 }

 if (null === $stability) {
 if (preg_match('{^[^,\s]*?@('.implode('|', array_keys(BasePackage::$stabilities)).')$}i', $packageVersion, $match)) {
 $stability = $match[1];
 } else {
 $stability = VersionParser::parseStability($packageVersion);
 }
 }

 $stability = VersionParser::normalizeStability($stability);

 if (!isset(BasePackage::$stabilities[$stability])) {
 throw new \InvalidArgumentException('Invalid stability provided ('.$stability.'), must be one of: '.implode(', ', array_keys(BasePackage::$stabilities)));
 }

 $pool = new Pool($stability);
 $pool->addRepository($sourceRepo);


 $versionSelector = new VersionSelector($pool);
 $package = $versionSelector->findBestCandidate($name, $packageVersion);

 if (!$package) {
 throw new \InvalidArgumentException("Could not find package $name" . ($packageVersion ? " with version $packageVersion." : " with stability $stability."));
 }

 if (null === $directory) {
 $parts = explode("/", $name, 2);
 $directory = getcwd() . DIRECTORY_SEPARATOR . array_pop($parts);
 }


 if (function_exists('pcntl_signal')) {
 declare (ticks = 100);
 pcntl_signal(SIGINT, function () use ($directory) {
 $fs = new Filesystem();
 $fs->removeDirectory($directory);
 exit(130);
 });
 }

 $io->writeError('<info>Installing ' . $package->getName() . ' (' . $package->getFullPrettyVersion(false) . ')</info>');

 if ($disablePlugins) {
 $io->writeError('<info>Plugins have been disabled.</info>');
 }

 if (0 === strpos($package->getPrettyVersion(), 'dev-') && in_array($package->getSourceType(), array('git', 'hg'))) {
 $package->setSourceReference(substr($package->getPrettyVersion(), 4));
 }

 $dm = $this->createDownloadManager($io, $config);
 $dm->setPreferSource($preferSource)
 ->setPreferDist($preferDist)
 ->setOutputProgress(!$noProgress);

 $projectInstaller = new ProjectInstaller($directory, $dm);
 $im = $this->createInstallationManager();
 $im->addInstaller($projectInstaller);
 $im->install(new InstalledFilesystemRepository(new JsonFile('php://memory')), new InstallOperation($package));
 $im->notifyInstalls();

 $installedFromVcs = 'source' === $package->getInstallationSource();

 $io->writeError('<info>Created project in ' . $directory . '</info>');
 chdir($directory);

 $_SERVER['COMPOSER_ROOT_VERSION'] = $package->getPrettyVersion();
 putenv('COMPOSER_ROOT_VERSION='.$_SERVER['COMPOSER_ROOT_VERSION']);

 return $installedFromVcs;
 }

 protected function createDownloadManager(IOInterface $io, Config $config)
 {
 $factory = new Factory();

 return $factory->createDownloadManager($io, $config);
 }

 protected function createInstallationManager()
 {
 return new InstallationManager();
 }








 protected function updatePreferredOptions(Config $config, InputInterface $input, &$preferSource, &$preferDist, $keepVcsRequiresPreferSource = false)
 {
 $preferSource = false;
 $preferDist = false;

 switch ($config->get('preferred-install')) {
 case 'source':
 $preferSource = true;
 break;
 case 'dist':
 $preferDist = true;
 break;
 case 'auto':
 default:

 break;
 }

 if ($input->getOption('prefer-source') || $input->getOption('prefer-dist') || ($keepVcsRequiresPreferSource && $input->getOption('keep-vcs'))) {
 $preferSource = $input->getOption('prefer-source') || ($keepVcsRequiresPreferSource && $input->getOption('keep-vcs'));
 $preferDist = $input->getOption('prefer-dist');
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\DependencyResolver\Pool;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;





 class DependsCommand extends Command
 {
 protected $linkTypes = array(
 'require' => array('requires', 'requires'),
 'require-dev' => array('devRequires', 'requires (dev)'),
 );

 protected function configure()
 {
 $this
 ->setName('depends')
 ->setDescription('Shows which packages depend on the given package')
 ->setDefinition(array(
 new InputArgument('package', InputArgument::REQUIRED, 'Package to inspect'),
 new InputOption('link-type', '', InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY, 'Link types to show (require, require-dev)', array_keys($this->linkTypes)),
 ))
 ->setHelp(<<<EOT
 Displays detailed information about where a package is referenced.

 <info>php composer.phar depends composer/composer</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $composer = $this->getComposer();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'depends', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $repo = $composer->getRepositoryManager()->getLocalRepository();
 $needle = $input->getArgument('package');

 $pool = new Pool();
 $pool->addRepository($repo);

 $packages = $pool->whatProvides($needle);
 if (empty($packages)) {
 throw new \InvalidArgumentException('Could not find package "'.$needle.'" in your project.');
 }

 $linkTypes = $this->linkTypes;

 $types = array_map(function ($type) use ($linkTypes) {
 $type = rtrim($type, 's');
 if (!isset($linkTypes[$type])) {
 throw new \InvalidArgumentException('Unexpected link type: '.$type.', valid types: '.implode(', ', array_keys($linkTypes)));
 }

 return $type;
 }, $input->getOption('link-type'));

 $messages = array();
 $outputPackages = array();
 foreach ($repo->getPackages() as $package) {
 foreach ($types as $type) {
 foreach ($package->{'get'.$linkTypes[$type][0]}() as $link) {
 if ($link->getTarget() === $needle) {
 if (!isset($outputPackages[$package->getName()])) {
 $messages[] = '<info>'.$package->getPrettyName() . '</info> ' . $linkTypes[$type][1] . ' ' . $needle .' (<info>' . $link->getPrettyConstraint() . '</info>)';
 $outputPackages[$package->getName()] = true;
 }
 }
 }
 }
 }

 if ($messages) {
 sort($messages);
 $this->getIO()->write($messages);
 } else {
 $this->getIO()->writeError('<info>There is no installed package depending on "'.$needle.'".</info>');
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Composer;
 use Composer\Factory;
 use Composer\Downloader\TransportException;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Composer\Util\ConfigValidator;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\RemoteFilesystem;
 use Composer\Util\StreamContextFactory;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;




 class DiagnoseCommand extends Command
 {

 protected $rfs;


 protected $process;


 protected $failures = 0;

 protected function configure()
 {
 $this
 ->setName('diagnose')
 ->setDescription('Diagnoses the system to identify common errors.')
 ->setHelp(<<<EOT
 The <info>diagnose</info> command checks common errors to help debugging problems.

 EOT
 )
 ;
 }




 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $composer = $this->getComposer(false);

 if ($composer) {
 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'diagnose', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $this->getIO()->write('Checking composer.json: ', false);
 $this->outputResult($this->checkComposerSchema());
 }

 if ($composer) {
 $config = $composer->getConfig();
 } else {
 $config = Factory::createConfig();
 }

 $this->rfs = new RemoteFilesystem($this->getIO(), $config);
 $this->process = new ProcessExecutor($this->getIO());

 $this->getIO()->write('Checking platform settings: ', false);
 $this->outputResult($this->checkPlatform());

 $this->getIO()->write('Checking git settings: ', false);
 $this->outputResult($this->checkGit());

 $this->getIO()->write('Checking http connectivity to packagist: ', false);
 $this->outputResult($this->checkHttp('http'));

 $this->getIO()->write('Checking https connectivity to packagist: ', false);
 $this->outputResult($this->checkHttp('https'));

 $opts = stream_context_get_options(StreamContextFactory::getContext('http://example.org'));
 if (!empty($opts['http']['proxy'])) {
 $this->getIO()->write('Checking HTTP proxy: ', false);
 $this->outputResult($this->checkHttpProxy());
 $this->getIO()->write('Checking HTTP proxy support for request_fulluri: ', false);
 $this->outputResult($this->checkHttpProxyFullUriRequestParam());
 $this->getIO()->write('Checking HTTPS proxy support for request_fulluri: ', false);
 $this->outputResult($this->checkHttpsProxyFullUriRequestParam());
 }

 if ($oauth = $config->get('github-oauth')) {
 foreach ($oauth as $domain => $token) {
 $this->getIO()->write('Checking '.$domain.' oauth access: ', false);
 $this->outputResult($this->checkGithubOauth($domain, $token));
 }
 } else {
 $this->getIO()->write('Checking github.com rate limit: ', false);
 try {
 $rate = $this->getGithubRateLimit('github.com');
 $this->outputResult(true);
 if (10 > $rate['remaining']) {
 $this->getIO()->write('<warning>WARNING</warning>');
 $this->getIO()->write(sprintf(
 '<comment>Github has a rate limit on their API. '
 . 'You currently have <options=bold>%u</options=bold> '
 . 'out of <options=bold>%u</options=bold> requests left.' . PHP_EOL
 . 'See https://developer.github.com/v3/#rate-limiting and also' . PHP_EOL
 . '    https://getcomposer.org/doc/articles/troubleshooting.md#api-rate-limit-and-oauth-tokens</comment>',
 $rate['remaining'],
 $rate['limit']
 ));
 }
 } catch (\Exception $e) {
 if ($e instanceof TransportException && $e->getCode() === 401) {
 $this->outputResult('<comment>The oauth token for github.com seems invalid, run "composer config --global --unset github-oauth.github.com" to remove it</comment>');
 } else {
 $this->outputResult($e);
 }
 }
 }

 $this->getIO()->write('Checking disk free space: ', false);
 $this->outputResult($this->checkDiskSpace($config));

 $this->getIO()->write('Checking composer version: ', false);
 $this->outputResult($this->checkVersion());

 return $this->failures;
 }

 private function checkComposerSchema()
 {
 $validator = new ConfigValidator($this->getIO());
 list($errors, $publishErrors, $warnings) = $validator->validate(Factory::getComposerFile());

 if ($errors || $publishErrors || $warnings) {
 $messages = array(
 'error' => array_merge($errors, $publishErrors),
 'warning' => $warnings,
 );

 $output = '';
 foreach ($messages as $style => $msgs) {
 foreach ($msgs as $msg) {
 $output .= '<' . $style . '>' . $msg . '</' . $style . '>' . PHP_EOL;
 }
 }

 return rtrim($output);
 }

 return true;
 }

 private function checkGit()
 {
 $this->process->execute('git config color.ui', $output);
 if (strtolower(trim($output)) === 'always') {
 return '<comment>Your git color.ui setting is set to always, this is known to create issues. Use "git config --global color.ui true" to set it correctly.</comment>';
 }

 return true;
 }

 private function checkHttp($proto)
 {
 try {
 $this->rfs->getContents('packagist.org', $proto . '://packagist.org/packages.json', false);
 } catch (\Exception $e) {
 return $e;
 }

 return true;
 }

 private function checkHttpProxy()
 {
 $protocol = extension_loaded('openssl') ? 'https' : 'http';
 try {
 $json = json_decode($this->rfs->getContents('packagist.org', $protocol . '://packagist.org/packages.json', false), true);
 $hash = reset($json['provider-includes']);
 $hash = $hash['sha256'];
 $path = str_replace('%hash%', $hash, key($json['provider-includes']));
 $provider = $this->rfs->getContents('packagist.org', $protocol . '://packagist.org/'.$path, false);

 if (hash('sha256', $provider) !== $hash) {
 return 'It seems that your proxy is modifying http traffic on the fly';
 }
 } catch (\Exception $e) {
 return $e;
 }

 return true;
 }








 private function checkHttpProxyFullUriRequestParam()
 {
 $url = 'http://packagist.org/packages.json';
 try {
 $this->rfs->getContents('packagist.org', $url, false);
 } catch (TransportException $e) {
 try {
 $this->rfs->getContents('packagist.org', $url, false, array('http' => array('request_fulluri' => false)));
 } catch (TransportException $e) {
 return 'Unable to assess the situation, maybe packagist.org is down ('.$e->getMessage().')';
 }

 return 'It seems there is a problem with your proxy server, try setting the "HTTP_PROXY_REQUEST_FULLURI" and "HTTPS_PROXY_REQUEST_FULLURI" environment variables to "false"';
 }

 return true;
 }








 private function checkHttpsProxyFullUriRequestParam()
 {
 if (!extension_loaded('openssl')) {
 return 'You need the openssl extension installed for this check';
 }

 $url = 'https://api.github.com/repos/Seldaek/jsonlint/zipball/1.0.0';
 try {
 $this->rfs->getContents('github.com', $url, false);
 } catch (TransportException $e) {
 try {
 $this->rfs->getContents('github.com', $url, false, array('http' => array('request_fulluri' => false)));
 } catch (TransportException $e) {
 return 'Unable to assess the situation, maybe github is down ('.$e->getMessage().')';
 }

 return 'It seems there is a problem with your proxy server, try setting the "HTTPS_PROXY_REQUEST_FULLURI" environment variable to "false"';
 }

 return true;
 }

 private function checkGithubOauth($domain, $token)
 {
 $this->getIO()->setAuthentication($domain, $token, 'x-oauth-basic');
 try {
 $url = $domain === 'github.com' ? 'https://api.'.$domain.'/user/repos' : 'https://'.$domain.'/api/v3/user/repos';

 return $this->rfs->getContents($domain, $url, false, array(
 'retry-auth-failure' => false
 )) ? true : 'Unexpected error';
 } catch (\Exception $e) {
 if ($e instanceof TransportException && $e->getCode() === 401) {
 return '<comment>The oauth token for '.$domain.' seems invalid, run "composer config --global --unset github-oauth.'.$domain.'" to remove it</comment>';
 }

 return $e;
 }
 }







 private function getGithubRateLimit($domain, $token = null)
 {
 if ($token) {
 $this->getIO()->setAuthentication($domain, $token, 'x-oauth-basic');
 }

 $url = $domain === 'github.com' ? 'https://api.'.$domain.'/rate_limit' : 'https://'.$domain.'/api/rate_limit';
 $json = $this->rfs->getContents($domain, $url, false, array('retry-auth-failure' => false));
 $data = json_decode($json, true);

 return $data['resources']['core'];
 }

 private function checkDiskSpace($config)
 {
 $minSpaceFree = 1024 * 1024;
 if ((($df = @disk_free_space($dir = $config->get('home'))) !== false && $df < $minSpaceFree)
 || (($df = @disk_free_space($dir = $config->get('vendor-dir'))) !== false && $df < $minSpaceFree)
 ) {
 return '<error>The disk hosting '.$dir.' is full</error>';
 }

 return true;
 }

 private function checkVersion()
 {
 $protocol = extension_loaded('openssl') ? 'https' : 'http';
 $latest = trim($this->rfs->getContents('getcomposer.org', $protocol . '://getcomposer.org/version', false));

 if (Composer::VERSION !== $latest && Composer::VERSION !== '@package_version@') {
 return '<comment>You are not running the latest version</comment>';
 }

 return true;
 }




 private function outputResult($result)
 {
 if (true === $result) {
 $this->getIO()->write('<info>OK</info>');
 } else {
 $this->failures++;
 $this->getIO()->write('<error>FAIL</error>');
 if ($result instanceof \Exception) {
 $this->getIO()->write('['.get_class($result).'] '.$result->getMessage());
 } elseif ($result) {
 $this->getIO()->write(trim($result));
 }
 }
 }

 private function checkPlatform()
 {
 $output = '';
 $out = function ($msg, $style) use (&$output) {
 $output .= '<'.$style.'>'.$msg.'</'.$style.'>'.PHP_EOL;
 };


 $errors = array();
 $warnings = array();

 $iniPath = php_ini_loaded_file();
 $displayIniMessage = false;
 if ($iniPath) {
 $iniMessage = PHP_EOL.PHP_EOL.'The php.ini used by your command-line PHP is: ' . $iniPath;
 } else {
 $iniMessage = PHP_EOL.PHP_EOL.'A php.ini file does not exist. You will have to create one.';
 }
 $iniMessage .= PHP_EOL.'If you can not modify the ini file, you can also run `php -d option=value` to modify ini values on the fly. You can use -d multiple times.';

 if (!function_exists('json_decode')) {
 $errors['json'] = true;
 }

 if (!extension_loaded('Phar')) {
 $errors['phar'] = true;
 }

 if (!extension_loaded('filter')) {
 $errors['filter'] = true;
 }

 if (!extension_loaded('hash')) {
 $errors['hash'] = true;
 }

 if (!ini_get('allow_url_fopen')) {
 $errors['allow_url_fopen'] = true;
 }

 if (extension_loaded('ionCube Loader') && ioncube_loader_iversion() < 40009) {
 $errors['ioncube'] = ioncube_loader_version();
 }

 if (PHP_VERSION_ID < 50302) {
 $errors['php'] = PHP_VERSION;
 }

 if (!isset($errors['php']) && PHP_VERSION_ID < 50304) {
 $warnings['php'] = PHP_VERSION;
 }

 if (!extension_loaded('openssl')) {
 $errors['openssl'] = true;
 }

 if (!defined('HHVM_VERSION') && !extension_loaded('apcu') && ini_get('apc.enable_cli')) {
 $warnings['apc_cli'] = true;
 }

 ob_start();
 phpinfo(INFO_GENERAL);
 $phpinfo = ob_get_clean();
 if (preg_match('{Configure Command(?: *</td><td class="v">| *=> *)(.*?)(?:</td>|$)}m', $phpinfo, $match)) {
 $configure = $match[1];

 if (false !== strpos($configure, '--enable-sigchild')) {
 $warnings['sigchild'] = true;
 }

 if (false !== strpos($configure, '--with-curlwrappers')) {
 $warnings['curlwrappers'] = true;
 }
 }

 if (ini_get('xdebug.profiler_enabled')) {
 $warnings['xdebug_profile'] = true;
 } elseif (extension_loaded('xdebug')) {
 $warnings['xdebug_loaded'] = true;
 }

 if (!empty($errors)) {
 foreach ($errors as $error => $current) {
 switch ($error) {
 case 'json':
 $text = PHP_EOL."The json extension is missing.".PHP_EOL;
 $text .= "Install it or recompile php without --disable-json";
 break;

 case 'phar':
 $text = PHP_EOL."The phar extension is missing.".PHP_EOL;
 $text .= "Install it or recompile php without --disable-phar";
 break;

 case 'filter':
 $text = PHP_EOL."The filter extension is missing.".PHP_EOL;
 $text .= "Install it or recompile php without --disable-filter";
 break;

 case 'hash':
 $text = PHP_EOL."The hash extension is missing.".PHP_EOL;
 $text .= "Install it or recompile php without --disable-hash";
 break;

 case 'unicode':
 $text = PHP_EOL."The detect_unicode setting must be disabled.".PHP_EOL;
 $text .= "Add the following to the end of your `php.ini`:".PHP_EOL;
 $text .= "    detect_unicode = Off";
 $displayIniMessage = true;
 break;

 case 'suhosin':
 $text = PHP_EOL."The suhosin.executor.include.whitelist setting is incorrect.".PHP_EOL;
 $text .= "Add the following to the end of your `php.ini` or suhosin.ini (Example path [for Debian]: /etc/php5/cli/conf.d/suhosin.ini):".PHP_EOL;
 $text .= "    suhosin.executor.include.whitelist = phar ".$current;
 $displayIniMessage = true;
 break;

 case 'php':
 $text = PHP_EOL."Your PHP ({$current}) is too old, you must upgrade to PHP 5.3.2 or higher.";
 break;

 case 'allow_url_fopen':
 $text = PHP_EOL."The allow_url_fopen setting is incorrect.".PHP_EOL;
 $text .= "Add the following to the end of your `php.ini`:".PHP_EOL;
 $text .= "    allow_url_fopen = On";
 $displayIniMessage = true;
 break;

 case 'ioncube':
 $text = PHP_EOL."Your ionCube Loader extension ($current) is incompatible with Phar files.".PHP_EOL;
 $text .= "Upgrade to ionCube 4.0.9 or higher or remove this line (path may be different) from your `php.ini` to disable it:".PHP_EOL;
 $text .= "    zend_extension = /usr/lib/php5/20090626+lfs/ioncube_loader_lin_5.3.so";
 $displayIniMessage = true;
 break;

 case 'openssl':
 $text = PHP_EOL."The openssl extension is missing, which means that secure HTTPS transfers are impossible.".PHP_EOL;
 $text .= "If possible you should enable it or recompile php with --with-openssl";
 break;
 }
 $out($text, 'error');
 }

 $output .= PHP_EOL;
 }

 if (!empty($warnings)) {
 foreach ($warnings as $warning => $current) {
 switch ($warning) {
 case 'apc_cli':
 $text = "The apc.enable_cli setting is incorrect.".PHP_EOL;
 $text .= "Add the following to the end of your `php.ini`:".PHP_EOL;
 $text .= "  apc.enable_cli = Off";
 $displayIniMessage = true;
 break;

 case 'sigchild':
 $text = "PHP was compiled with --enable-sigchild which can cause issues on some platforms.".PHP_EOL;
 $text .= "Recompile it without this flag if possible, see also:".PHP_EOL;
 $text .= "  https://bugs.php.net/bug.php?id=22999";
 break;

 case 'curlwrappers':
 $text = "PHP was compiled with --with-curlwrappers which will cause issues with HTTP authentication and GitHub.".PHP_EOL;
 $text .= " Recompile it without this flag if possible";
 break;

 case 'php':
 $text = "Your PHP ({$current}) is quite old, upgrading to PHP 5.3.4 or higher is recommended.".PHP_EOL;
 $text .= " Composer works with 5.3.2+ for most people, but there might be edge case issues.";
 break;

 case 'xdebug_loaded':
 $text = "The xdebug extension is loaded, this can slow down Composer a little.".PHP_EOL;
 $text .= " Disabling it when using Composer is recommended.";
 break;

 case 'xdebug_profile':
 $text = "The xdebug.profiler_enabled setting is enabled, this can slow down Composer a lot.".PHP_EOL;
 $text .= "Add the following to the end of your `php.ini` to disable it:".PHP_EOL;
 $text .= "  xdebug.profiler_enabled = 0";
 $displayIniMessage = true;
 break;
 }
 $out($text, 'comment');
 }
 }

 if ($displayIniMessage) {
 $out($iniMessage, 'comment');
 }

 return !$warnings && !$errors ? true : $output;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;




 class DumpAutoloadCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('dump-autoload')
 ->setAliases(array('dumpautoload'))
 ->setDescription('Dumps the autoloader')
 ->setDefinition(array(
 new InputOption('optimize', 'o', InputOption::VALUE_NONE, 'Optimizes PSR0 and PSR4 packages to be loaded with classmaps too, good for production.'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables autoload-dev rules.'),
 ))
 ->setHelp(<<<EOT
 <info>php composer.phar dump-autoload</info>
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $composer = $this->getComposer();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'dump-autoload', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $installationManager = $composer->getInstallationManager();
 $localRepo = $composer->getRepositoryManager()->getLocalRepository();
 $package = $composer->getPackage();
 $config = $composer->getConfig();

 $optimize = $input->getOption('optimize') || $config->get('optimize-autoloader') || $config->get('classmap-authoritative');

 if ($optimize) {
 $this->getIO()->writeError('<info>Generating optimized autoload files</info>');
 } else {
 $this->getIO()->writeError('<info>Generating autoload files</info>');
 }

 $generator = $composer->getAutoloadGenerator();
 $generator->setDevMode(!$input->getOption('no-dev'));
 $generator->dump($config, $localRepo, $package, $installationManager, 'composer', $optimize);
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Factory;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\StringInput;
 use Symfony\Component\Console\Output\OutputInterface;




 class GlobalCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('global')
 ->setDescription('Allows running commands in the global composer dir ($COMPOSER_HOME).')
 ->setDefinition(array(
 new InputArgument('command-name', InputArgument::REQUIRED, ''),
 new InputArgument('args', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, ''),
 ))
 ->setHelp(<<<EOT
 Use this command as a wrapper to run other Composer commands
 within the global context of COMPOSER_HOME.

 You can use this to install CLI utilities globally, all you need
 is to add the COMPOSER_HOME/vendor/bin dir to your PATH env var.

 COMPOSER_HOME is c:\Users\<user>\AppData\Roaming\Composer on Windows
 and /home/<user>/.composer on unix systems.

 Note: This path may vary depending on customizations to bin-dir in
 composer.json or the environmental variable COMPOSER_BIN_DIR.

 EOT
 )
 ;
 }

 public function run(InputInterface $input, OutputInterface $output)
 {

 $tokens = preg_split('{\s+}', $input->__toString());
 $args = array();
 foreach ($tokens as $token) {
 if ($token && $token[0] !== '-') {
 $args[] = $token;
 if (count($args) >= 2) {
 break;
 }
 }
 }


 if (count($args) < 2) {
 return parent::run($input, $output);
 }


 $config = Factory::createConfig();
 chdir($config->get('home'));
 $this->getIO()->writeError('<info>Changed current directory to '.$config->get('home').'</info>');


 $input = new StringInput(preg_replace('{\bg(?:l(?:o(?:b(?:a(?:l)?)?)?)?)?\b}', '', $input->__toString(), 1));

 return $this->getApplication()->run($input, $output);
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Factory;
 use Composer\Package\CompletePackageInterface;
 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\ArrayRepository;
 use Composer\Util\ProcessExecutor;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;




 class HomeCommand extends Command
 {



 protected function configure()
 {
 $this
 ->setName('browse')
 ->setAliases(array('home'))
 ->setDescription('Opens the package\'s repository URL or homepage in your browser.')
 ->setDefinition(array(
 new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::REQUIRED, 'Package(s) to browse to.'),
 new InputOption('homepage', 'H', InputOption::VALUE_NONE, 'Open the homepage instead of the repository URL.'),
 new InputOption('show', 's', InputOption::VALUE_NONE, 'Only show the homepage or repository URL.'),
 ))
 ->setHelp(<<<EOT
 The home command opens or shows a package's repository URL or
 homepage in your default browser.

 To open the homepage by default, use -H or --homepage.
 To show instead of open the repository or homepage URL, use -s or --show.
 EOT
 );
 }




 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $repos = $this->initializeRepos();
 $return = 0;

 foreach ($input->getArgument('packages') as $packageName) {
 $handled = false;
 $packageExists = false;
 foreach ($repos as $repo) {
 foreach ($repo->findPackages($packageName) as $package) {
 $packageExists = true;
 if ($this->handlePackage($package, $input->getOption('homepage'), $input->getOption('show'))) {
 $handled = true;
 break 2;
 }
 }
 }

 if (!$packageExists) {
 $return = 1;
 $this->getIO()->writeError('<warning>Package '.$packageName.' not found</warning>');
 }

 if (!$handled) {
 $return = 1;
 $this->getIO()->writeError('<warning>'.($input->getOption('homepage') ? 'Invalid or missing homepage' : 'Invalid or missing repository URL').' for '.$packageName.'</warning>');
 }
 }

 return $return;
 }

 private function handlePackage(CompletePackageInterface $package, $showHomepage, $showOnly)
 {
 $support = $package->getSupport();
 $url = isset($support['source']) ? $support['source'] : $package->getSourceUrl();
 if (!$url || $showHomepage) {
 $url = $package->getHomepage();
 }

 if (!$url || !filter_var($url, FILTER_VALIDATE_URL)) {
 return false;
 }

 if ($showOnly) {
 $this->getIO()->write(sprintf('<info>%s</info>', $url));
 } else {
 $this->openBrowser($url);
 }

 return true;
 }






 private function openBrowser($url)
 {
 $url = ProcessExecutor::escape($url);

 if (defined('PHP_WINDOWS_VERSION_MAJOR')) {
 return passthru('start "web" explorer "' . $url . '"');
 }

 passthru('which xdg-open', $linux);
 passthru('which open', $osx);

 if (0 === $linux) {
 passthru('xdg-open ' . $url);
 } elseif (0 === $osx) {
 passthru('open ' . $url);
 } else {
 $this->getIO()->writeError('no suitable browser opening command found, open yourself: ' . $url);
 }
 }








 private function initializeRepos()
 {
 $composer = $this->getComposer(false);

 if ($composer) {
 return array_merge(
 array(new ArrayRepository(array($composer->getPackage()))), 
 array($composer->getRepositoryManager()->getLocalRepository()), 
 $composer->getRepositoryManager()->getRepositories() 
 );
 }

 $defaultRepos = Factory::createDefaultRepositories($this->getIO());

 return $defaultRepos;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\DependencyResolver\Pool;
 use Composer\Json\JsonFile;
 use Composer\Factory;
 use Composer\Package\BasePackage;
 use Composer\Package\Version\VersionSelector;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\PlatformRepository;
 use Composer\Package\Version\VersionParser;
 use Composer\Util\ProcessExecutor;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Process\Process;
 use Symfony\Component\Process\ExecutableFinder;





 class InitCommand extends Command
 {

 protected $repos;


 private $gitConfig;


 private $pool;




 protected function configure()
 {
 $this
 ->setName('init')
 ->setDescription('Creates a basic composer.json file in current directory.')
 ->setDefinition(array(
 new InputOption('name', null, InputOption::VALUE_REQUIRED, 'Name of the package'),
 new InputOption('description', null, InputOption::VALUE_REQUIRED, 'Description of package'),
 new InputOption('author', null, InputOption::VALUE_REQUIRED, 'Author name of package'),

 new InputOption('type', null, InputOption::VALUE_OPTIONAL, 'Type of package'),
 new InputOption('homepage', null, InputOption::VALUE_REQUIRED, 'Homepage of package'),
 new InputOption('require', null, InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED, 'Package to require with a version constraint, e.g. foo/bar:1.0.0 or foo/bar=1.0.0 or "foo/bar 1.0.0"'),
 new InputOption('require-dev', null, InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED, 'Package to require for development with a version constraint, e.g. foo/bar:1.0.0 or foo/bar=1.0.0 or "foo/bar 1.0.0"'),
 new InputOption('stability', 's', InputOption::VALUE_REQUIRED, 'Minimum stability (empty or one of: '.implode(', ', array_keys(BasePackage::$stabilities)).')'),
 new InputOption('license', 'l', InputOption::VALUE_REQUIRED, 'License of package'),
 ))
 ->setHelp(<<<EOT
 The <info>init</info> command creates a basic composer.json file
 in the current directory.

 <info>php composer.phar init</info>

 EOT
 )
 ;
 }




 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $whitelist = array('name', 'description', 'author', 'type', 'homepage', 'require', 'require-dev', 'stability', 'license');

 $options = array_filter(array_intersect_key($input->getOptions(), array_flip($whitelist)));

 if (isset($options['author'])) {
 $options['authors'] = $this->formatAuthors($options['author']);
 unset($options['author']);
 }

 if (isset($options['stability'])) {
 $options['minimum-stability'] = $options['stability'];
 unset($options['stability']);
 }

 $options['require'] = isset($options['require']) ? $this->formatRequirements($options['require']) : new \stdClass;
 if (array() === $options['require']) {
 $options['require'] = new \stdClass;
 }

 if (isset($options['require-dev'])) {
 $options['require-dev'] = $this->formatRequirements($options['require-dev']);
 if (array() === $options['require-dev']) {
 $options['require-dev'] = new \stdClass;
 }
 }

 $file = new JsonFile('composer.json');
 $json = $file->encode($options);

 if ($input->isInteractive()) {
 $this->getIO()->writeError(array('', $json, ''));
 if (!$this->getIO()->askConfirmation('Do you confirm generation [<comment>yes</comment>]? ', true)) {
 $this->getIO()->writeError('<error>Command aborted</error>');

 return 1;
 }
 }

 $file->write($options);

 if ($input->isInteractive() && is_dir('.git')) {
 $ignoreFile = realpath('.gitignore');

 if (false === $ignoreFile) {
 $ignoreFile = realpath('.') . '/.gitignore';
 }

 if (!$this->hasVendorIgnore($ignoreFile)) {
 $question = 'Would you like the <info>vendor</info> directory added to your <info>.gitignore</info> [<comment>yes</comment>]? ';

 if ($this->getIO()->askConfirmation($question, true)) {
 $this->addVendorIgnore($ignoreFile);
 }
 }
 }
 }




 protected function interact(InputInterface $input, OutputInterface $output)
 {
 $git = $this->getGitConfig();

 $formatter = $this->getHelperSet()->get('formatter');

 $this->getIO()->writeError(array(
 '',
 $formatter->formatBlock('Welcome to the Composer config generator', 'bg=blue;fg=white', true),
 ''
 ));


 $this->getIO()->writeError(array(
 '',
 'This command will guide you through creating your composer.json config.',
 '',
 ));

 $cwd = realpath(".");

 if (!$name = $input->getOption('name')) {
 $name = basename($cwd);
 $name = preg_replace('{(?:([a-z])([A-Z])|([A-Z])([A-Z][a-z]))}', '\\1\\3-\\2\\4', $name);
 $name = strtolower($name);
 if (isset($git['github.user'])) {
 $name = $git['github.user'] . '/' . $name;
 } elseif (!empty($_SERVER['USERNAME'])) {
 $name = $_SERVER['USERNAME'] . '/' . $name;
 } elseif (get_current_user()) {
 $name = get_current_user() . '/' . $name;
 } else {

 $name = $name . '/' . $name;
 }
 } else {
 if (!preg_match('{^[a-z0-9_.-]+/[a-z0-9_.-]+$}', $name)) {
 throw new \InvalidArgumentException(
 'The package name '.$name.' is invalid, it should be lowercase and have a vendor name, a forward slash, and a package name, matching: [a-z0-9_.-]+/[a-z0-9_.-]+'
 );
 }
 }

 $name = $this->getIO()->askAndValidate(
 'Package name (<vendor>/<name>) [<comment>'.$name.'</comment>]: ',
 function ($value) use ($name) {
 if (null === $value) {
 return $name;
 }

 if (!preg_match('{^[a-z0-9_.-]+/[a-z0-9_.-]+$}', $value)) {
 throw new \InvalidArgumentException(
 'The package name '.$value.' is invalid, it should be lowercase and have a vendor name, a forward slash, and a package name, matching: [a-z0-9_.-]+/[a-z0-9_.-]+'
 );
 }

 return $value;
 },
 null,
 $name
 );
 $input->setOption('name', $name);

 $description = $input->getOption('description') ?: false;
 $description = $this->getIO()->ask(
 'Description [<comment>'.$description.'</comment>]: ',
 $description
 );
 $input->setOption('description', $description);

 if (null === $author = $input->getOption('author')) {
 if (isset($git['user.name']) && isset($git['user.email'])) {
 $author = sprintf('%s <%s>', $git['user.name'], $git['user.email']);
 }
 }

 $self = $this;
 $author = $this->getIO()->askAndValidate(
 'Author [<comment>'.$author.'</comment>]: ',
 function ($value) use ($self, $author) {
 $value = $value ?: $author;
 $author = $self->parseAuthorString($value);

 return sprintf('%s <%s>', $author['name'], $author['email']);
 },
 null,
 $author
 );
 $input->setOption('author', $author);

 $minimumStability = $input->getOption('stability') ?: null;
 $minimumStability = $this->getIO()->askAndValidate(
 'Minimum Stability [<comment>'.$minimumStability.'</comment>]: ',
 function ($value) use ($self, $minimumStability) {
 if (null === $value) {
 return $minimumStability;
 }

 if (!isset(BasePackage::$stabilities[$value])) {
 throw new \InvalidArgumentException(
 'Invalid minimum stability "'.$value.'". Must be empty or one of: '.
 implode(', ', array_keys(BasePackage::$stabilities))
 );
 }

 return $value;
 },
 null,
 $minimumStability
 );
 $input->setOption('stability', $minimumStability);

 $type = $input->getOption('type') ?: false;
 $type = $this->getIO()->ask(
 'Package Type [<comment>'.$type.'</comment>]: ',
 $type
 );
 $input->setOption('type', $type);

 $license = $input->getOption('license') ?: false;
 $license = $this->getIO()->ask(
 'License [<comment>'.$license.'</comment>]: ',
 $license
 );
 $input->setOption('license', $license);

 $this->getIO()->writeError(array('', 'Define your dependencies.', ''));

 $question = 'Would you like to define your dependencies (require) interactively [<comment>yes</comment>]? ';
 $requirements = array();
 if ($this->getIO()->askConfirmation($question, true)) {
 $requirements = $this->determineRequirements($input, $output, $input->getOption('require'));
 }
 $input->setOption('require', $requirements);

 $question = 'Would you like to define your dev dependencies (require-dev) interactively [<comment>yes</comment>]? ';
 $devRequirements = array();
 if ($this->getIO()->askConfirmation($question, true)) {
 $devRequirements = $this->determineRequirements($input, $output, $input->getOption('require-dev'));
 }
 $input->setOption('require-dev', $devRequirements);
 }






 public function parseAuthorString($author)
 {
 if (preg_match('/^(?P<name>[- \.,\p{L}\p{N}\'’]+) <(?P<email>.+?)>$/u', $author, $match)) {
 if ($this->isValidEmail($match['email'])) {
 return array(
 'name' => trim($match['name']),
 'email' => $match['email']
 );
 }
 }

 throw new \InvalidArgumentException(
 'Invalid author string.  Must be in the format: '.
 'John Smith <[email protected]>'
 );
 }

 protected function findPackages($name)
 {
 return $this->getRepos()->search($name);
 }

 protected function getRepos()
 {
 if (!$this->repos) {
 $this->repos = new CompositeRepository(array_merge(
 array(new PlatformRepository),
 Factory::createDefaultRepositories($this->getIO())
 ));
 }

 return $this->repos;
 }

 protected function determineRequirements(InputInterface $input, OutputInterface $output, $requires = array())
 {
 if ($requires) {
 $requires = $this->normalizeRequirements($requires);
 $result = array();

 foreach ($requires as $requirement) {
 if (!isset($requirement['version'])) {

 $version = $this->findBestVersionForPackage($input, $requirement['name']);
 $requirement['version'] = $version;

 $this->getIO()->writeError(sprintf(
 'Using version <info>%s</info> for <info>%s</info>',
 $requirement['version'],
 $requirement['name']
 ));
 }

 $result[] = $requirement['name'] . ' ' . $requirement['version'];
 }

 return $result;
 }

 $versionParser = new VersionParser();
 while (null !== $package = $this->getIO()->ask('Search for a package: ')) {
 $matches = $this->findPackages($package);

 if (count($matches)) {
 $exactMatch = null;
 $choices = array();
 foreach ($matches as $position => $foundPackage) {
 $choices[] = sprintf(' <info>%5s</info> %s', "[$position]", $foundPackage['name']);
 if ($foundPackage['name'] === $package) {
 $exactMatch = true;
 break;
 }
 }


 if (!$exactMatch) {
 $this->getIO()->writeError(array(
 '',
 sprintf('Found <info>%s</info> packages matching <info>%s</info>', count($matches), $package),
 ''
 ));

 $this->getIO()->writeError($choices);
 $this->getIO()->writeError('');

 $validator = function ($selection) use ($matches, $versionParser) {
 if ('' === $selection) {
 return false;
 }

 if (is_numeric($selection) && isset($matches[(int) $selection])) {
 $package = $matches[(int) $selection];

 return $package['name'];
 }

 if (preg_match('{^\s*(?P<name>[\S/]+)(?:\s+(?P<version>\S+))?\s*$}', $selection, $packageMatches)) {
 if (isset($packageMatches['version'])) {



 $versionParser->parseConstraints($packageMatches['version']);

 return $packageMatches['name'].' '.$packageMatches['version'];
 }


 return $packageMatches['name'];
 }

 throw new \Exception('Not a valid selection');
 };

 $package = $this->getIO()->askAndValidate(
 'Enter package # to add, or the complete package name if it is not listed: ',
 $validator,
 3,
 false
 );
 }


 if (false !== $package && false === strpos($package, ' ')) {
 $validator = function ($input) {
 $input = trim($input);

 return $input ?: false;
 };

 $constraint = $this->getIO()->askAndValidate(
 'Enter the version constraint to require (or leave blank to use the latest version): ',
 $validator,
 3,
 false
 );

 if (false === $constraint) {
 $constraint = $this->findBestVersionForPackage($input, $package);

 $this->getIO()->writeError(sprintf(
 'Using version <info>%s</info> for <info>%s</info>',
 $constraint,
 $package
 ));
 }

 $package .= ' '.$constraint;
 }

 if (false !== $package) {
 $requires[] = $package;
 }
 }
 }

 return $requires;
 }

 protected function formatAuthors($author)
 {
 return array($this->parseAuthorString($author));
 }

 protected function formatRequirements(array $requirements)
 {
 $requires = array();
 $requirements = $this->normalizeRequirements($requirements);
 foreach ($requirements as $requirement) {
 $requires[$requirement['name']] = $requirement['version'];
 }

 return $requires;
 }

 protected function getGitConfig()
 {
 if (null !== $this->gitConfig) {
 return $this->gitConfig;
 }

 $finder = new ExecutableFinder();
 $gitBin = $finder->find('git');

 $cmd = new Process(sprintf('%s config -l', ProcessExecutor::escape($gitBin)));
 $cmd->run();

 if ($cmd->isSuccessful()) {
 $this->gitConfig = array();
 preg_match_all('{^([^=]+)=(.*)$}m', $cmd->getOutput(), $matches, PREG_SET_ORDER);
 foreach ($matches as $match) {
 $this->gitConfig[$match[1]] = $match[2];
 }

 return $this->gitConfig;
 }

 return $this->gitConfig = array();
 }

















 protected function hasVendorIgnore($ignoreFile, $vendor = 'vendor')
 {
 if (!file_exists($ignoreFile)) {
 return false;
 }

 $pattern = sprintf('{^/?%s(/\*?)?$}', preg_quote($vendor));

 $lines = file($ignoreFile, FILE_IGNORE_NEW_LINES);
 foreach ($lines as $line) {
 if (preg_match($pattern, $line)) {
 return true;
 }
 }

 return false;
 }

 protected function normalizeRequirements(array $requirements)
 {
 $parser = new VersionParser();

 return $parser->parseNameVersionPairs($requirements);
 }

 protected function addVendorIgnore($ignoreFile, $vendor = '/vendor/')
 {
 $contents = "";
 if (file_exists($ignoreFile)) {
 $contents = file_get_contents($ignoreFile);

 if ("\n" !== substr($contents, 0, -1)) {
 $contents .= "\n";
 }
 }

 file_put_contents($ignoreFile, $contents . $vendor. "\n");
 }

 protected function isValidEmail($email)
 {

 if (!function_exists('filter_var')) {
 return true;
 }


 if (PHP_VERSION_ID < 50303) {
 return true;
 }

 return false !== filter_var($email, FILTER_VALIDATE_EMAIL);
 }

 private function getPool(InputInterface $input)
 {
 if (!$this->pool) {
 $this->pool = new Pool($this->getMinimumStability($input));
 $this->pool->addRepository($this->getRepos());
 }

 return $this->pool;
 }

 private function getMinimumStability(InputInterface $input)
 {
 if ($input->hasOption('stability')) {
 return $input->getOption('stability') ?: 'stable';
 }

 $file = Factory::getComposerFile();
 if (is_file($file) && is_readable($file) && is_array($composer = json_decode(file_get_contents($file), true))) {
 if (!empty($composer['minimum-stability'])) {
 return $composer['minimum-stability'];
 }
 }

 return 'stable';
 }











 private function findBestVersionForPackage(InputInterface $input, $name)
 {

 $versionSelector = new VersionSelector($this->getPool($input));
 $package = $versionSelector->findBestCandidate($name);

 if (!$package) {
 throw new \InvalidArgumentException(sprintf(
 'Could not find package %s at any version for your minimum-stability (%s). Check the package spelling or your minimum-stability',
 $name,
 $this->getMinimumStability($input)
 ));
 }

 return $versionSelector->findRecommendedRequireVersion($package);
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Installer;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;







 class InstallCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('install')
 ->setDescription('Installs the project dependencies from the composer.lock file if present, or falls back on the composer.json.')
 ->setDefinition(array(
 new InputOption('prefer-source', null, InputOption::VALUE_NONE, 'Forces installation from package sources when possible, including VCS information.'),
 new InputOption('prefer-dist', null, InputOption::VALUE_NONE, 'Forces installation from package dist even for dev versions.'),
 new InputOption('dry-run', null, InputOption::VALUE_NONE, 'Outputs the operations but will not execute anything (implicitly enables --verbose).'),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Enables installation of require-dev packages (enabled by default, only present for BC).'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables installation of require-dev packages.'),
 new InputOption('no-plugins', null, InputOption::VALUE_NONE, 'Disables all plugins.'),
 new InputOption('no-custom-installers', null, InputOption::VALUE_NONE, 'DEPRECATED: Use no-plugins instead.'),
 new InputOption('no-autoloader', null, InputOption::VALUE_NONE, 'Skips autoloader generation'),
 new InputOption('no-scripts', null, InputOption::VALUE_NONE, 'Skips the execution of all scripts defined in composer.json file.'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 new InputOption('verbose', 'v|vv|vvv', InputOption::VALUE_NONE, 'Shows more details including new commits pulled in when updating packages.'),
 new InputOption('optimize-autoloader', 'o', InputOption::VALUE_NONE, 'Optimize autoloader during autoloader dump'),
 new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
 new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Should not be provided, use composer require instead to add a given package to composer.json.'),
 ))
 ->setHelp(<<<EOT
 The <info>install</info> command reads the composer.lock file from
 the current directory, processes it, and downloads and installs all the
 libraries and dependencies outlined in that file. If the file does not
 exist it will look for composer.json and do the same.

 <info>php composer.phar install</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 if ($args = $input->getArgument('packages')) {
 $this->getIO()->writeError('<error>Invalid argument '.implode(' ', $args).'. Use "composer require '.implode(' ', $args).'" instead to add packages to your composer.json.</error>');

 return 1;
 }

 if ($input->getOption('no-custom-installers')) {
 $this->getIO()->writeError('<warning>You are using the deprecated option "no-custom-installers". Use "no-plugins" instead.</warning>');
 $input->setOption('no-plugins', true);
 }

 if ($input->getOption('dev')) {
 $this->getIO()->writeError('<warning>You are using the deprecated option "dev". Dev packages are installed by default now.</warning>');
 }

 $composer = $this->getComposer(true, $input->getOption('no-plugins'));
 $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
 $io = $this->getIO();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'install', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $install = Installer::create($io, $composer);

 $preferSource = false;
 $preferDist = false;

 $config = $composer->getConfig();

 switch ($config->get('preferred-install')) {
 case 'source':
 $preferSource = true;
 break;
 case 'dist':
 $preferDist = true;
 break;
 case 'auto':
 default:

 break;
 }
 if ($input->getOption('prefer-source') || $input->getOption('prefer-dist')) {
 $preferSource = $input->getOption('prefer-source');
 $preferDist = $input->getOption('prefer-dist');
 }

 $optimize = $input->getOption('optimize-autoloader') || $config->get('optimize-autoloader') || $config->get('classmap-authoritative');

 $install
 ->setDryRun($input->getOption('dry-run'))
 ->setVerbose($input->getOption('verbose'))
 ->setPreferSource($preferSource)
 ->setPreferDist($preferDist)
 ->setDevMode(!$input->getOption('no-dev'))
 ->setDumpAutoloader(!$input->getOption('no-autoloader'))
 ->setRunScripts(!$input->getOption('no-scripts'))
 ->setOptimizeAutoloader($optimize)
 ->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'))
 ;

 if ($input->getOption('no-plugins')) {
 $install->disablePlugins();
 }

 return $install->run();
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Json\JsonFile;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Composer\Package\PackageInterface;
 use Composer\Repository\RepositoryInterface;
 use Symfony\Component\Console\Helper\Table;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;




 class LicensesCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('licenses')
 ->setDescription('Show information about licenses of dependencies')
 ->setDefinition(array(
 new InputOption('format', 'f', InputOption::VALUE_REQUIRED, 'Format of the output: text or json', 'text'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables search in require-dev packages.'),
 ))
 ->setHelp(<<<EOT
 The license command displays detailed information about the licenses of
 the installed dependencies.

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $composer = $this->getComposer();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'licenses', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $root = $composer->getPackage();
 $repo = $composer->getRepositoryManager()->getLocalRepository();

 if ($input->getOption('no-dev')) {
 $packages = $this->filterRequiredPackages($repo, $root);
 } else {
 $packages = $this->appendPackages($repo->getPackages(), array());
 }

 ksort($packages);

 switch ($format = $input->getOption('format')) {
 case 'text':
 $this->getIO()->write('Name: <comment>'.$root->getPrettyName().'</comment>');
 $this->getIO()->write('Version: <comment>'.$root->getFullPrettyVersion().'</comment>');
 $this->getIO()->write('Licenses: <comment>'.(implode(', ', $root->getLicense()) ?: 'none').'</comment>');
 $this->getIO()->write('Dependencies:');
 $this->getIO()->write('');

 $table = new Table($output);
 $table->setStyle('compact');
 $table->getStyle()->setVerticalBorderChar('');
 $table->getStyle()->setCellRowContentFormat('%s  ');
 $table->setHeaders(array('Name', 'Version', 'License'));
 foreach ($packages as $package) {
 $table->addRow(array(
 $package->getPrettyName(),
 $package->getFullPrettyVersion(),
 implode(', ', $package->getLicense()) ?: 'none',
 ));
 }
 $table->render();
 break;

 case 'json':
 foreach ($packages as $package) {
 $dependencies[$package->getPrettyName()] = array(
 'version' => $package->getFullPrettyVersion(),
 'license' => $package->getLicense(),
 );
 }

 $this->getIO()->write(JsonFile::encode(array(
 'name' => $root->getPrettyName(),
 'version' => $root->getFullPrettyVersion(),
 'license' => $root->getLicense(),
 'dependencies' => $dependencies,
 )));
 break;

 default:
 throw new \RuntimeException(sprintf('Unsupported format "%s".  See help for supported formats.', $format));
 }
 }







 private function filterRequiredPackages(RepositoryInterface $repo, PackageInterface $package, $bucket = array())
 {
 $requires = array_keys($package->getRequires());

 $packageListNames = array_keys($bucket);
 $packages = array_filter(
 $repo->getPackages(),
 function ($package) use ($requires, $packageListNames) {
 return in_array($package->getName(), $requires) && !in_array($package->getName(), $packageListNames);
 }
 );

 $bucket = $this->appendPackages($packages, $bucket);

 foreach ($packages as $package) {
 $bucket = $this->filterRequiredPackages($repo, $package, $bucket);
 }

 return $bucket;
 }








 public function appendPackages(array $packages, array $bucket)
 {
 foreach ($packages as $package) {
 $bucket[$package->getName()] = $package;
 }

 return $bucket;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Config\JsonConfigSource;
 use Composer\Installer;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Composer\Json\JsonFile;
 use Composer\Factory;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;





 class RemoveCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('remove')
 ->setDescription('Removes a package from the require or require-dev')
 ->setDefinition(array(
 new InputArgument('packages', InputArgument::IS_ARRAY, 'Packages that should be removed.'),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Removes a package from the require-dev section.'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 new InputOption('no-update', null, InputOption::VALUE_NONE, 'Disables the automatic update of the dependencies.'),
 new InputOption('update-no-dev', null, InputOption::VALUE_NONE, 'Run the dependency update with the --no-dev option.'),
 new InputOption('update-with-dependencies', null, InputOption::VALUE_NONE, 'Allows inherited dependencies to be updated with explicit dependencies.'),
 new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
 ))
 ->setHelp(<<<EOT
 The <info>remove</info> command removes a package from the current
 list of installed packages

 <info>php composer.phar remove</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $packages = $input->getArgument('packages');

 $file = Factory::getComposerFile();

 $jsonFile = new JsonFile($file);
 $composer = $jsonFile->read();
 $composerBackup = file_get_contents($jsonFile->getPath());

 $json = new JsonConfigSource($jsonFile);

 $type = $input->getOption('dev') ? 'require-dev' : 'require';
 $altType = !$input->getOption('dev') ? 'require-dev' : 'require';

 foreach ($packages as $package) {
 if (isset($composer[$type][$package])) {
 $json->removeLink($type, $package);
 } elseif (isset($composer[$altType][$package])) {
 $this->getIO()->writeError('<warning>'.$package.' could not be found in '.$type.' but it is present in '.$altType.'</warning>');
 if ($this->getIO()->isInteractive()) {
 if ($this->getIO()->askConfirmation('Do you want to remove it from '.$altType.' [<comment>yes</comment>]? ', true)) {
 $json->removeLink($altType, $package);
 }
 }
 } else {
 $this->getIO()->writeError('<warning>'.$package.' is not required in your composer.json and has not been removed</warning>');
 }
 }

 if ($input->getOption('no-update')) {
 return 0;
 }


 $composer = $this->getComposer();
 $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
 $io = $this->getIO();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'remove', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $install = Installer::create($io, $composer);

 $updateDevMode = !$input->getOption('update-no-dev');
 $install
 ->setVerbose($input->getOption('verbose'))
 ->setDevMode($updateDevMode)
 ->setUpdate(true)
 ->setUpdateWhitelist($packages)
 ->setWhitelistDependencies($input->getOption('update-with-dependencies'))
 ->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'))
 ;

 $status = $install->run();
 if ($status !== 0) {
 $this->getIO()->writeError("\n".'<error>Removal failed, reverting '.$file.' to its original content.</error>');
 file_put_contents($jsonFile->getPath(), $composerBackup);
 }

 return $status;
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Composer\Factory;
 use Composer\Installer;
 use Composer\Json\JsonFile;
 use Composer\Json\JsonManipulator;
 use Composer\Package\Version\VersionParser;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\PlatformRepository;





 class RequireCommand extends InitCommand
 {
 protected function configure()
 {
 $this
 ->setName('require')
 ->setDescription('Adds required packages to your composer.json and installs them')
 ->setDefinition(array(
 new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Required package name optionally including a version constraint, e.g. foo/bar or foo/bar:1.0.0 or foo/bar=1.0.0 or "foo/bar 1.0.0"'),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Add requirement to require-dev.'),
 new InputOption('prefer-source', null, InputOption::VALUE_NONE, 'Forces installation from package sources when possible, including VCS information.'),
 new InputOption('prefer-dist', null, InputOption::VALUE_NONE, 'Forces installation from package dist even for dev versions.'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 new InputOption('no-update', null, InputOption::VALUE_NONE, 'Disables the automatic update of the dependencies.'),
 new InputOption('update-no-dev', null, InputOption::VALUE_NONE, 'Run the dependency update with the --no-dev option.'),
 new InputOption('update-with-dependencies', null, InputOption::VALUE_NONE, 'Allows inherited dependencies to be updated with explicit dependencies.'),
 new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
 new InputOption('sort-packages', null, InputOption::VALUE_NONE, 'Sorts packages when adding/updating a new dependency'),
 ))
 ->setHelp(<<<EOT
 The require command adds required packages to your composer.json and installs them.

 If you do not specify a version constraint, composer will choose a suitable one based on the available package versions.

 If you do not want to install the new dependencies immediately you can call it with --no-update

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $file = Factory::getComposerFile();

 $newlyCreated = !file_exists($file);
 if (!file_exists($file) && !file_put_contents($file, "{\n}\n")) {
 $this->getIO()->writeError('<error>'.$file.' could not be created.</error>');

 return 1;
 }
 if (!is_readable($file)) {
 $this->getIO()->writeError('<error>'.$file.' is not readable.</error>');

 return 1;
 }
 if (!is_writable($file)) {
 $this->getIO()->writeError('<error>'.$file.' is not writable.</error>');

 return 1;
 }

 if (filesize($file) === 0) {
 file_put_contents($file, "{\n}\n");
 }

 $json = new JsonFile($file);
 $composerDefinition = $json->read();
 $composerBackup = file_get_contents($json->getPath());

 $composer = $this->getComposer();
 $repos = $composer->getRepositoryManager()->getRepositories();

 $this->repos = new CompositeRepository(array_merge(
 array(new PlatformRepository),
 $repos
 ));

 $requirements = $this->determineRequirements($input, $output, $input->getArgument('packages'));

 $requireKey = $input->getOption('dev') ? 'require-dev' : 'require';
 $removeKey = $input->getOption('dev') ? 'require' : 'require-dev';
 $baseRequirements = array_key_exists($requireKey, $composerDefinition) ? $composerDefinition[$requireKey] : array();
 $requirements = $this->formatRequirements($requirements);


 $versionParser = new VersionParser();
 foreach ($requirements as $constraint) {
 $versionParser->parseConstraints($constraint);
 }

 $sortPackages = $input->getOption('sort-packages');

 if (!$this->updateFileCleanly($json, $baseRequirements, $requirements, $requireKey, $removeKey, $sortPackages)) {
 foreach ($requirements as $package => $version) {
 $baseRequirements[$package] = $version;

 if (isset($composerDefinition[$removeKey][$package])) {
 unset($composerDefinition[$removeKey][$package]);
 }
 }

 $composerDefinition[$requireKey] = $baseRequirements;
 $json->write($composerDefinition);
 }

 $this->getIO()->writeError('<info>'.$file.' has been '.($newlyCreated ? 'created' : 'updated').'</info>');

 if ($input->getOption('no-update')) {
 return 0;
 }
 $updateDevMode = !$input->getOption('update-no-dev');


 $this->resetComposer();
 $composer = $this->getComposer();
 $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
 $io = $this->getIO();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'require', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $install = Installer::create($io, $composer);

 $install
 ->setVerbose($input->getOption('verbose'))
 ->setPreferSource($input->getOption('prefer-source'))
 ->setPreferDist($input->getOption('prefer-dist'))
 ->setDevMode($updateDevMode)
 ->setUpdate(true)
 ->setUpdateWhitelist(array_keys($requirements))
 ->setWhitelistDependencies($input->getOption('update-with-dependencies'))
 ->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'))
 ;

 $status = $install->run();
 if ($status !== 0) {
 if ($newlyCreated) {
 $this->getIO()->writeError("\n".'<error>Installation failed, deleting '.$file.'.</error>');
 unlink($json->getPath());
 } else {
 $this->getIO()->writeError("\n".'<error>Installation failed, reverting '.$file.' to its original content.</error>');
 file_put_contents($json->getPath(), $composerBackup);
 }
 }

 return $status;
 }

 private function updateFileCleanly($json, array $base, array $new, $requireKey, $removeKey, $sortPackages)
 {
 $contents = file_get_contents($json->getPath());

 $manipulator = new JsonManipulator($contents);

 foreach ($new as $package => $constraint) {
 if (!$manipulator->addLink($requireKey, $package, $constraint, $sortPackages)) {
 return false;
 }
 if (!$manipulator->removeSubNode($removeKey, $package)) {
 return false;
 }
 }

 file_put_contents($json->getPath(), $manipulator->getContents());

 return true;
 }

 protected function interact(InputInterface $input, OutputInterface $output)
 {
 return;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Script\CommandEvent;
 use Composer\Script\ScriptEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;




 class RunScriptCommand extends Command
 {



 protected $scriptEvents = array(
 ScriptEvents::PRE_INSTALL_CMD,
 ScriptEvents::POST_INSTALL_CMD,
 ScriptEvents::PRE_UPDATE_CMD,
 ScriptEvents::POST_UPDATE_CMD,
 ScriptEvents::PRE_STATUS_CMD,
 ScriptEvents::POST_STATUS_CMD,
 ScriptEvents::POST_ROOT_PACKAGE_INSTALL,
 ScriptEvents::POST_CREATE_PROJECT_CMD,
 ScriptEvents::PRE_ARCHIVE_CMD,
 ScriptEvents::POST_ARCHIVE_CMD,
 ScriptEvents::PRE_AUTOLOAD_DUMP,
 ScriptEvents::POST_AUTOLOAD_DUMP,
 );

 protected function configure()
 {
 $this
 ->setName('run-script')
 ->setDescription('Run the scripts defined in composer.json.')
 ->setDefinition(array(
 new InputArgument('script', InputArgument::OPTIONAL, 'Script name to run.'),
 new InputArgument('args', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, ''),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Sets the dev mode.'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables the dev mode.'),
 new InputOption('list', 'l', InputOption::VALUE_NONE, 'List scripts.'),
 ))
 ->setHelp(<<<EOT
 The <info>run-script</info> command runs scripts defined in composer.json:

 <info>php composer.phar run-script post-update-cmd</info>
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 if ($input->getOption('list')) {
 return $this->listScripts();
 } elseif (!$input->getArgument('script')) {
 throw new \RunTimeException('Missing required argument "script"');
 }

 $script = $input->getArgument('script');
 if (!in_array($script, $this->scriptEvents)) {
 if (defined('Composer\Script\ScriptEvents::'.str_replace('-', '_', strtoupper($script)))) {
 throw new \InvalidArgumentException(sprintf('Script "%s" cannot be run with this command', $script));
 }
 }

 $composer = $this->getComposer();
 $hasListeners = $composer->getEventDispatcher()->hasEventListeners(new CommandEvent($script, $composer, $this->getIO()));
 if (!$hasListeners) {
 throw new \InvalidArgumentException(sprintf('Script "%s" is not defined in this package', $script));
 }


 $binDir = $composer->getConfig()->get('bin-dir');
 if (is_dir($binDir)) {
 $_SERVER['PATH'] = realpath($binDir).PATH_SEPARATOR.getenv('PATH');
 putenv('PATH='.$_SERVER['PATH']);
 }

 $args = $input->getArgument('args');

 return $composer->getEventDispatcher()->dispatchScript($script, $input->getOption('dev') || !$input->getOption('no-dev'), $args);
 }

 protected function listScripts()
 {
 $scripts = $this->getComposer()->getPackage()->getScripts();

 if (!count($scripts)) {
 return 0;
 }

 $this->getIO()->writeError('<info>scripts:</info>');
 foreach ($scripts as $name => $script) {
 $this->getIO()->write('  ' . $name);
 }

 return 0;
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;




 class ScriptAliasCommand extends Command
 {
 private $script;

 public function __construct($script)
 {
 $this->script = $script;

 parent::__construct();
 }

 protected function configure()
 {
 $this
 ->setName($this->script)
 ->setDescription('Run the '.$this->script.' script as defined in composer.json.')
 ->setDefinition(array(
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Sets the dev mode.'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables the dev mode.'),
 new InputArgument('args', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, ''),
 ))
 ->setHelp(<<<EOT
 The <info>run-script</info> command runs scripts defined in composer.json:

 <info>php composer.phar run-script post-update-cmd</info>
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $composer = $this->getComposer();


 $binDir = $composer->getConfig()->get('bin-dir');
 if (is_dir($binDir)) {
 $_SERVER['PATH'] = realpath($binDir).PATH_SEPARATOR.getenv('PATH');
 putenv('PATH='.$_SERVER['PATH']);
 }

 $args = $input->getArguments();

 return $composer->getEventDispatcher()->dispatchScript($this->script, $input->getOption('dev') || !$input->getOption('no-dev'), $args['args']);
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\PlatformRepository;
 use Composer\Repository\RepositoryInterface;
 use Composer\Factory;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;




 class SearchCommand extends Command
 {
 protected $matches;
 protected $lowMatches = array();
 protected $tokens;
 protected $output;
 protected $onlyName;

 protected function configure()
 {
 $this
 ->setName('search')
 ->setDescription('Search for packages')
 ->setDefinition(array(
 new InputOption('only-name', 'N', InputOption::VALUE_NONE, 'Search only in name'),
 new InputArgument('tokens', InputArgument::IS_ARRAY | InputArgument::REQUIRED, 'tokens to search for'),
 ))
 ->setHelp(<<<EOT
 The search command searches for packages by its name
 <info>php composer.phar search symfony composer</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {

 $platformRepo = new PlatformRepository;
 if ($composer = $this->getComposer(false)) {
 $localRepo = $composer->getRepositoryManager()->getLocalRepository();
 $installedRepo = new CompositeRepository(array($localRepo, $platformRepo));
 $repos = new CompositeRepository(array_merge(array($installedRepo), $composer->getRepositoryManager()->getRepositories()));
 } else {
 $defaultRepos = Factory::createDefaultRepositories($this->getIO());
 $this->getIO()->writeError('No composer.json found in the current directory, showing packages from ' . implode(', ', array_keys($defaultRepos)));
 $installedRepo = $platformRepo;
 $repos = new CompositeRepository(array_merge(array($installedRepo), $defaultRepos));
 }

 if ($composer) {
 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'search', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
 }

 $onlyName = $input->getOption('only-name');

 $flags = $onlyName ? RepositoryInterface::SEARCH_NAME : RepositoryInterface::SEARCH_FULLTEXT;
 $results = $repos->search(implode(' ', $input->getArgument('tokens')), $flags);

 foreach ($results as $result) {
 $this->getIO()->write($result['name'] . (isset($result['description']) ? ' '. $result['description'] : ''));
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Composer;
 use Composer\Factory;
 use Composer\Util\Filesystem;
 use Composer\Util\RemoteFilesystem;
 use Composer\Downloader\FilesystemException;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Finder\Finder;






 class SelfUpdateCommand extends Command
 {
 const HOMEPAGE = 'getcomposer.org';
 const OLD_INSTALL_EXT = '-old.phar';

 protected function configure()
 {
 $this
 ->setName('self-update')
 ->setAliases(array('selfupdate'))
 ->setDescription('Updates composer.phar to the latest version.')
 ->setDefinition(array(
 new InputOption('rollback', 'r', InputOption::VALUE_NONE, 'Revert to an older installation of composer'),
 new InputOption('clean-backups', null, InputOption::VALUE_NONE, 'Delete old backups during an update. This makes the current version of composer the only backup available after the update'),
 new InputArgument('version', InputArgument::OPTIONAL, 'The version to update to'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 ))
 ->setHelp(<<<EOT
 The <info>self-update</info> command checks getcomposer.org for newer
 versions of composer and if found, installs the latest.

 <info>php composer.phar self-update</info>

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $baseUrl = (extension_loaded('openssl') ? 'https' : 'http') . '://' . self::HOMEPAGE;
 $config = Factory::createConfig();
 $remoteFilesystem = new RemoteFilesystem($this->getIO(), $config);
 $cacheDir = $config->get('cache-dir');
 $rollbackDir = $config->get('home');
 $localFilename = realpath($_SERVER['argv'][0]) ?: $_SERVER['argv'][0];


 $tmpDir = is_writable(dirname($localFilename)) ? dirname($localFilename) : $cacheDir;


 if (!is_writable($tmpDir)) {
 throw new FilesystemException('Composer update failed: the "'.$tmpDir.'" directory used to download the temp file could not be written');
 }
 if (!is_writable($localFilename)) {
 throw new FilesystemException('Composer update failed: the "'.$localFilename.'" file could not be written');
 }

 if ($input->getOption('rollback')) {
 return $this->rollback($output, $rollbackDir, $localFilename);
 }

 $latestVersion = trim($remoteFilesystem->getContents(self::HOMEPAGE, $baseUrl. '/version', false));
 $updateVersion = $input->getArgument('version') ?: $latestVersion;

 if (preg_match('{^[0-9a-f]{40}$}', $updateVersion) && $updateVersion !== $latestVersion) {
 $this->getIO()->writeError('<error>You can not update to a specific SHA-1 as those phars are not available for download</error>');

 return 1;
 }

 if (Composer::VERSION === $updateVersion) {
 $this->getIO()->writeError('<info>You are already using composer version '.$updateVersion.'.</info>');

 return 0;
 }

 $tempFilename = $tmpDir . '/' . basename($localFilename, '.phar').'-temp.phar';
 $backupFile = sprintf(
 '%s/%s-%s%s',
 $rollbackDir,
 strtr(Composer::RELEASE_DATE, ' :', '_-'),
 preg_replace('{^([0-9a-f]{7})[0-9a-f]{33}$}', '$1', Composer::VERSION),
 self::OLD_INSTALL_EXT
 );

 $this->getIO()->writeError(sprintf("Updating to version <info>%s</info>.", $updateVersion));
 $remoteFilename = $baseUrl . (preg_match('{^[0-9a-f]{40}$}', $updateVersion) ? '/composer.phar' : "/download/{$updateVersion}/composer.phar");
 $remoteFilesystem->copy(self::HOMEPAGE, $remoteFilename, $tempFilename, !$input->getOption('no-progress'));
 if (!file_exists($tempFilename)) {
 $this->getIO()->writeError('<error>The download of the new composer version failed for an unexpected reason</error>');

 return 1;
 }


 if ($input->getOption('clean-backups')) {
 $finder = $this->getOldInstallationFinder($rollbackDir);

 $fs = new Filesystem;
 foreach ($finder as $file) {
 $file = (string) $file;
 $this->getIO()->writeError('<info>Removing: '.$file.'</info>');
 $fs->remove($file);
 }
 }

 if ($err = $this->setLocalPhar($localFilename, $tempFilename, $backupFile)) {
 $this->getIO()->writeError('<error>The file is corrupted ('.$err->getMessage().').</error>');
 $this->getIO()->writeError('<error>Please re-run the self-update command to try again.</error>');

 return 1;
 }

 if (file_exists($backupFile)) {
 $this->getIO()->writeError('Use <info>composer self-update --rollback</info> to return to version '.Composer::VERSION);
 } else {
 $this->getIO()->writeError('<warning>A backup of the current version could not be written to '.$backupFile.', no rollback possible</warning>');
 }
 }

 protected function rollback(OutputInterface $output, $rollbackDir, $localFilename)
 {
 $rollbackVersion = $this->getLastBackupVersion($rollbackDir);
 if (!$rollbackVersion) {
 throw new \UnexpectedValueException('Composer rollback failed: no installation to roll back to in "'.$rollbackDir.'"');
 }

 if (!is_writable($rollbackDir)) {
 throw new FilesystemException('Composer rollback failed: the "'.$rollbackDir.'" dir could not be written to');
 }

 $old = $rollbackDir . '/' . $rollbackVersion . self::OLD_INSTALL_EXT;

 if (!is_file($old)) {
 throw new FilesystemException('Composer rollback failed: "'.$old.'" could not be found');
 }
 if (!is_readable($old)) {
 throw new FilesystemException('Composer rollback failed: "'.$old.'" could not be read');
 }

 $oldFile = $rollbackDir . "/{$rollbackVersion}" . self::OLD_INSTALL_EXT;
 $this->getIO()->writeError(sprintf("Rolling back to version <info>%s</info>.", $rollbackVersion));
 if ($err = $this->setLocalPhar($localFilename, $oldFile)) {
 $this->getIO()->writeError('<error>The backup file was corrupted ('.$err->getMessage().') and has been removed.</error>');

 return 1;
 }

 return 0;
 }

 protected function setLocalPhar($localFilename, $newFilename, $backupTarget = null)
 {
 try {
 @chmod($newFilename, fileperms($localFilename));
 if (!ini_get('phar.readonly')) {

 $phar = new \Phar($newFilename);

 unset($phar);
 }


 if ($backupTarget && file_exists($localFilename)) {
 @copy($localFilename, $backupTarget);
 }

 rename($newFilename, $localFilename);
 } catch (\Exception $e) {
 if ($backupTarget) {
 @unlink($newFilename);
 }
 if (!$e instanceof \UnexpectedValueException && !$e instanceof \PharException) {
 throw $e;
 }

 return $e;
 }
 }

 protected function getLastBackupVersion($rollbackDir)
 {
 $finder = $this->getOldInstallationFinder($rollbackDir);
 $finder->sortByName();
 $files = iterator_to_array($finder);

 if (count($files)) {
 return basename(end($files), self::OLD_INSTALL_EXT);
 }

 return false;
 }

 protected function getOldInstallationFinder($rollbackDir)
 {
 $finder = Finder::create()
 ->depth(0)
 ->files()
 ->name('*' . self::OLD_INSTALL_EXT)
 ->in($rollbackDir);

 return $finder;
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\DefaultPolicy;
 use Composer\Factory;
 use Composer\Package\CompletePackageInterface;
 use Composer\Package\Version\VersionParser;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Composer\Repository\ArrayRepository;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\ComposerRepository;
 use Composer\Repository\PlatformRepository;
 use Composer\Repository\RepositoryInterface;
 use Composer\Spdx\SpdxLicenses;





 class ShowCommand extends Command
 {
 protected $versionParser;

 protected function configure()
 {
 $this
 ->setName('show')
 ->setAliases(array('info'))
 ->setDescription('Show information about packages')
 ->setDefinition(array(
 new InputArgument('package', InputArgument::OPTIONAL, 'Package to inspect'),
 new InputArgument('version', InputArgument::OPTIONAL, 'Version or version constraint to inspect'),
 new InputOption('installed', 'i', InputOption::VALUE_NONE, 'List installed packages only'),
 new InputOption('platform', 'p', InputOption::VALUE_NONE, 'List platform packages only'),
 new InputOption('available', 'a', InputOption::VALUE_NONE, 'List available packages only'),
 new InputOption('self', 's', InputOption::VALUE_NONE, 'Show the root package information'),
 new InputOption('name-only', 'N', InputOption::VALUE_NONE, 'List package names only'),
 new InputOption('path', 'P', InputOption::VALUE_NONE, 'Show package paths'),
 ))
 ->setHelp(<<<EOT
 The show command displays detailed information about a package, or
 lists all packages available.

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $this->versionParser = new VersionParser;


 $platformRepo = new PlatformRepository;

 $composer = $this->getComposer(false);
 if ($input->getOption('self')) {
 $package = $this->getComposer()->getPackage();
 $repos = $installedRepo = new ArrayRepository(array($package));
 } elseif ($input->getOption('platform')) {
 $repos = $installedRepo = $platformRepo;
 } elseif ($input->getOption('installed')) {
 $repos = $installedRepo = $this->getComposer()->getRepositoryManager()->getLocalRepository();
 } elseif ($input->getOption('available')) {
 $installedRepo = $platformRepo;
 if ($composer) {
 $repos = new CompositeRepository($composer->getRepositoryManager()->getRepositories());
 } else {
 $defaultRepos = Factory::createDefaultRepositories($this->getIO());
 $repos = new CompositeRepository($defaultRepos);
 $this->getIO()->writeError('No composer.json found in the current directory, showing available packages from ' . implode(', ', array_keys($defaultRepos)));
 }
 } elseif ($composer) {
 $localRepo = $composer->getRepositoryManager()->getLocalRepository();
 $installedRepo = new CompositeRepository(array($localRepo, $platformRepo));
 $repos = new CompositeRepository(array_merge(array($installedRepo), $composer->getRepositoryManager()->getRepositories()));
 } else {
 $defaultRepos = Factory::createDefaultRepositories($this->getIO());
 $this->getIO()->writeError('No composer.json found in the current directory, showing available packages from ' . implode(', ', array_keys($defaultRepos)));
 $installedRepo = $platformRepo;
 $repos = new CompositeRepository(array_merge(array($installedRepo), $defaultRepos));
 }

 if ($composer) {
 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'show', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
 }


 if ($input->getArgument('package') || !empty($package)) {
 $versions = array();
 if (empty($package)) {
 list($package, $versions) = $this->getPackage($installedRepo, $repos, $input->getArgument('package'), $input->getArgument('version'));

 if (!$package) {
 throw new \InvalidArgumentException('Package '.$input->getArgument('package').' not found');
 }
 } else {
 $versions = array($package->getPrettyVersion() => $package->getVersion());
 }

 $this->printMeta($package, $versions, $installedRepo);
 $this->printLinks($package, 'requires');
 $this->printLinks($package, 'devRequires', 'requires (dev)');
 if ($package->getSuggests()) {
 $this->getIO()->write("\n<info>suggests</info>");
 foreach ($package->getSuggests() as $suggested => $reason) {
 $this->getIO()->write($suggested . ' <comment>' . $reason . '</comment>');
 }
 }
 $this->printLinks($package, 'provides');
 $this->printLinks($package, 'conflicts');
 $this->printLinks($package, 'replaces');

 return;
 }


 $packages = array();

 if ($repos instanceof CompositeRepository) {
 $repos = $repos->getRepositories();
 } elseif (!is_array($repos)) {
 $repos = array($repos);
 }

 foreach ($repos as $repo) {
 if ($repo === $platformRepo) {
 $type = '<info>platform</info>:';
 } elseif (
 $repo === $installedRepo
 || ($installedRepo instanceof CompositeRepository && in_array($repo, $installedRepo->getRepositories(), true))
 ) {
 $type = '<info>installed</info>:';
 } else {
 $type = '<comment>available</comment>:';
 }
 if ($repo instanceof ComposerRepository && $repo->hasProviders()) {
 foreach ($repo->getProviderNames() as $name) {
 $packages[$type][$name] = $name;
 }
 } else {
 foreach ($repo->getPackages() as $package) {
 if (!isset($packages[$type][$package->getName()])
 || !is_object($packages[$type][$package->getName()])
 || version_compare($packages[$type][$package->getName()]->getVersion(), $package->getVersion(), '<')
 ) {
 $packages[$type][$package->getName()] = $package;
 }
 }
 }
 }

 $tree = !$input->getOption('platform') && !$input->getOption('installed') && !$input->getOption('available');
 $indent = $tree ? '  ' : '';
 foreach (array('<info>platform</info>:' => true, '<comment>available</comment>:' => false, '<info>installed</info>:' => true) as $type => $showVersion) {
 if (isset($packages[$type])) {
 if ($tree) {
 $this->getIO()->write($type);
 }
 ksort($packages[$type]);

 $nameLength = $versionLength = 0;
 foreach ($packages[$type] as $package) {
 if (is_object($package)) {
 $nameLength = max($nameLength, strlen($package->getPrettyName()));
 $versionLength = max($versionLength, strlen($package->getFullPrettyVersion()));
 } else {
 $nameLength = max($nameLength, $package);
 }
 }
 list($width) = $this->getApplication()->getTerminalDimensions();
 if (null === $width) {

 
 $width = PHP_INT_MAX;
 }
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $width--;
 }

 if ($input->getOption('path') && null === $composer) {
 $this->getIO()->writeError('No composer.json found in the current directory, disabling "path" option');
 $input->setOption('path', false);
 }

 $writePath = !$input->getOption('name-only') && $input->getOption('path');
 $writeVersion = !$input->getOption('name-only') && !$input->getOption('path') && $showVersion && ($nameLength + $versionLength + 3 <= $width);
 $writeDescription = !$input->getOption('name-only') && !$input->getOption('path') && ($nameLength + ($showVersion ? $versionLength : 0) + 24 <= $width);
 foreach ($packages[$type] as $package) {
 if (is_object($package)) {
 $output->write($indent . str_pad($package->getPrettyName(), $nameLength, ' '), false);

 if ($writeVersion) {
 $output->write(' ' . str_pad($package->getFullPrettyVersion(), $versionLength, ' '), false);
 }

 if ($writeDescription) {
 $description = strtok($package->getDescription(), "\r\n");
 $remaining = $width - $nameLength - $versionLength - 4;
 if (strlen($description) > $remaining) {
 $description = substr($description, 0, $remaining - 3) . '...';
 }
 $output->write(' ' . $description);
 }

 if ($writePath) {
 $path = strtok(realpath($composer->getInstallationManager()->getInstallPath($package)), "\r\n");
 $output->write(' ' . $path);
 }
 } else {
 $output->write($indent . $package);
 }
 $this->getIO()->write('');
 }
 if ($tree) {
 $this->getIO()->write('');
 }
 }
 }
 }











 protected function getPackage(RepositoryInterface $installedRepo, RepositoryInterface $repos, $name, $version = null)
 {
 $name = strtolower($name);
 $constraint = null;
 if ($version) {
 $constraint = $this->versionParser->parseConstraints($version);
 }

 $policy = new DefaultPolicy();
 $pool = new Pool('dev');
 $pool->addRepository($repos);

 $matchedPackage = null;
 $versions = array();
 $matches = $pool->whatProvides($name, $constraint);
 foreach ($matches as $index => $package) {

 if ($package->getName() !== $name) {
 unset($matches[$index]);
 continue;
 }


 if (null === $version && $installedRepo->hasPackage($package)) {
 $matchedPackage = $package;
 }

 $versions[$package->getPrettyVersion()] = $package->getVersion();
 $matches[$index] = $package->getId();
 }


 if (!$matchedPackage && $matches && $preferred = $policy->selectPreferredPackages($pool, array(), $matches)) {
 $matchedPackage = $pool->literalToPackage($preferred[0]);
 }

 return array($matchedPackage, $versions);
 }




 protected function printMeta(CompletePackageInterface $package, array $versions, RepositoryInterface $installedRepo)
 {
 $this->getIO()->write('<info>name</info>     : ' . $package->getPrettyName());
 $this->getIO()->write('<info>descrip.</info> : ' . $package->getDescription());
 $this->getIO()->write('<info>keywords</info> : ' . join(', ', $package->getKeywords() ?: array()));
 $this->printVersions($package, $versions, $installedRepo);
 $this->getIO()->write('<info>type</info>     : ' . $package->getType());
 $this->printLicenses($package);
 $this->getIO()->write('<info>source</info>   : ' . sprintf('[%s] <comment>%s</comment> %s', $package->getSourceType(), $package->getSourceUrl(), $package->getSourceReference()));
 $this->getIO()->write('<info>dist</info>     : ' . sprintf('[%s] <comment>%s</comment> %s', $package->getDistType(), $package->getDistUrl(), $package->getDistReference()));
 $this->getIO()->write('<info>names</info>    : ' . implode(', ', $package->getNames()));

 if ($package->isAbandoned()) {
 $replacement = ($package->getReplacementPackage() !== null)
 ? ' The author suggests using the ' . $package->getReplacementPackage(). ' package instead.'
 : null;

 $this->getIO()->writeError(
 sprintf('<warning>Attention: This package is abandoned and no longer maintained.%s</warning>', $replacement)
 );
 }

 if ($package->getSupport()) {
 $this->getIO()->write("\n<info>support</info>");
 foreach ($package->getSupport() as $type => $value) {
 $this->getIO()->write('<comment>' . $type . '</comment> : '.$value);
 }
 }

 if ($package->getAutoload()) {
 $this->getIO()->write("\n<info>autoload</info>");
 foreach ($package->getAutoload() as $type => $autoloads) {
 $this->getIO()->write('<comment>' . $type . '</comment>');

 if ($type === 'psr-0') {
 foreach ($autoloads as $name => $path) {
 $this->getIO()->write(($name ?: '*') . ' => ' . (is_array($path) ? implode(', ', $path) : ($path ?: '.')));
 }
 } elseif ($type === 'psr-4') {
 foreach ($autoloads as $name => $path) {
 $this->getIO()->write(($name ?: '*') . ' => ' . (is_array($path) ? implode(', ', $path) : ($path ?: '.')));
 }
 } elseif ($type === 'classmap') {
 $this->getIO()->write(implode(', ', $autoloads));
 }
 }
 if ($package->getIncludePaths()) {
 $this->getIO()->write('<comment>include-path</comment>');
 $this->getIO()->write(implode(', ', $package->getIncludePaths()));
 }
 }
 }




 protected function printVersions(CompletePackageInterface $package, array $versions, RepositoryInterface $installedRepo)
 {
 uasort($versions, 'version_compare');
 $versions = array_keys(array_reverse($versions));


 if ($installedRepo->hasPackage($package)) {
 $installedVersion = $package->getPrettyVersion();
 $key = array_search($installedVersion, $versions);
 if (false !== $key) {
 $versions[$key] = '<info>* ' . $installedVersion . '</info>';
 }
 }

 $versions = implode(', ', $versions);

 $this->getIO()->write('<info>versions</info> : ' . $versions);
 }








 protected function printLinks(CompletePackageInterface $package, $linkType, $title = null)
 {
 $title = $title ?: $linkType;
 if ($links = $package->{'get'.ucfirst($linkType)}()) {
 $this->getIO()->write("\n<info>" . $title . "</info>");

 foreach ($links as $link) {
 $this->getIO()->write($link->getTarget() . ' <comment>' . $link->getPrettyConstraint() . '</comment>');
 }
 }
 }






 protected function printLicenses(CompletePackageInterface $package)
 {
 $spdxLicenses = new SpdxLicenses();

 $licenses = $package->getLicense();

 foreach ($licenses as $licenseId) {
 $license = $spdxLicenses->getLicenseByIdentifier($licenseId); 

 if (!$license) {
 $out = $licenseId;
 } else {

 if ($license[1] === true) {
 $out = sprintf('%s (%s) (OSI approved) %s', $license[0], $licenseId, $license[2]);
 } else {
 $out = sprintf('%s (%s) %s', $license[0], $licenseId, $license[2]);
 }
 }

 $this->getIO()->write('<info>license</info>  : ' . $out);
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 use Composer\Downloader\ChangeReportInterface;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Composer\Script\ScriptEvents;





 class StatusCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('status')
 ->setDescription('Show a list of locally modified packages')
 ->setDefinition(array(
 new InputOption('verbose', 'v|vv|vvv', InputOption::VALUE_NONE, 'Show modified files for each directory that contains changes.'),
 ))
 ->setHelp(<<<EOT
 The status command displays a list of dependencies that have
 been modified locally.

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {

 $composer = $this->getComposer();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'status', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $installedRepo = $composer->getRepositoryManager()->getLocalRepository();

 $dm = $composer->getDownloadManager();
 $im = $composer->getInstallationManager();


 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::PRE_STATUS_CMD, true);

 $errors = array();


 foreach ($installedRepo->getPackages() as $package) {
 $downloader = $dm->getDownloaderForInstalledPackage($package);

 if ($downloader instanceof ChangeReportInterface) {
 $targetDir = $im->getInstallPath($package);

 if (is_link($targetDir)) {
 $errors[$targetDir] = $targetDir . ' is a symbolic link.';
 }

 if ($changes = $downloader->getLocalChanges($package, $targetDir)) {
 $errors[$targetDir] = $changes;
 }
 }
 }


 if (!$errors) {
 $this->getIO()->writeError('<info>No local changes</info>');
 } else {
 $this->getIO()->writeError('<error>You have changes in the following dependencies:</error>');
 }

 foreach ($errors as $path => $changes) {
 if ($input->getOption('verbose')) {
 $indentedChanges = implode("\n", array_map(function ($line) {
 return '    ' . ltrim($line);
 }, explode("\n", $changes)));
 $this->getIO()->write('<info>'.$path.'</info>:');
 $this->getIO()->write($indentedChanges);
 } else {
 $this->getIO()->write($path);
 }
 }

 if ($errors && !$input->getOption('verbose')) {
 $this->getIO()->writeError('Use --verbose (-v) to see modified files');
 }


 $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_STATUS_CMD, true);

 return $errors ? 1 : 0;
 }
 }
 <?php











 namespace Composer\Command;

 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;

 class SuggestsCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('suggests')
 ->setDescription('Show package suggestions')
 ->setDefinition(array(
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Exclude suggestions from require-dev packages'),
 new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Packages that you want to list suggestions from.'),
 ))
 ->setHelp(<<<EOT

 The <info>%command.name%</info> command shows suggested packages.

 With <info>-v</info> you also see which package suggested it and why.

 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $lock = $this->getComposer()->getLocker()->getLockData();

 if (empty($lock)) {
 throw new \RuntimeException('Lockfile seems to be empty?');
 }

 $packages = $lock['packages'];

 if (!$input->getOption('no-dev')) {
 $packages += $lock['packages-dev'];
 }

 $filter = $input->getArgument('packages');

 foreach ($packages as $package) {
 if (empty($package['suggest'])) {
 continue;
 }

 if (!empty($filter) && !in_array($package['name'], $filter)) {
 continue;
 }

 $this->printSuggestions($packages, $package['name'], $package['suggest']);
 }
 }

 protected function printSuggestions($installed, $source, $suggestions)
 {
 foreach ($suggestions as $suggestion => $reason) {
 foreach ($installed as $package) {
 if ($package['name'] === $suggestion) {
 continue 2;
 }
 }

 if (empty($reason)) {
 $reason = '*';
 }

 $this->printSuggestion($source, $suggestion, $reason);
 }
 }

 protected function printSuggestion($package, $suggestion, $reason)
 {
 $io = $this->getIO();

 if ($io->isVerbose()) {
 $io->write(sprintf('<comment>%s</comment> suggests <info>%s</info>: %s', $package, $suggestion, $reason));
 } else {
 $io->write(sprintf('<info>%s</info>', $suggestion));
 }
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Installer;
 use Composer\Plugin\CommandEvent;
 use Composer\Plugin\PluginEvents;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Output\OutputInterface;





 class UpdateCommand extends Command
 {
 protected function configure()
 {
 $this
 ->setName('update')
 ->setDescription('Updates your dependencies to the latest version according to composer.json, and updates the composer.lock file.')
 ->setDefinition(array(
 new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Packages that should be updated, if not provided all packages are.'),
 new InputOption('prefer-source', null, InputOption::VALUE_NONE, 'Forces installation from package sources when possible, including VCS information.'),
 new InputOption('prefer-dist', null, InputOption::VALUE_NONE, 'Forces installation from package dist even for dev versions.'),
 new InputOption('dry-run', null, InputOption::VALUE_NONE, 'Outputs the operations but will not execute anything (implicitly enables --verbose).'),
 new InputOption('dev', null, InputOption::VALUE_NONE, 'Enables installation of require-dev packages (enabled by default, only present for BC).'),
 new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables installation of require-dev packages.'),
 new InputOption('lock', null, InputOption::VALUE_NONE, 'Only updates the lock file hash to suppress warning about the lock file being out of date.'),
 new InputOption('no-plugins', null, InputOption::VALUE_NONE, 'Disables all plugins.'),
 new InputOption('no-custom-installers', null, InputOption::VALUE_NONE, 'DEPRECATED: Use no-plugins instead.'),
 new InputOption('no-autoloader', null, InputOption::VALUE_NONE, 'Skips autoloader generation'),
 new InputOption('no-scripts', null, InputOption::VALUE_NONE, 'Skips the execution of all scripts defined in composer.json file.'),
 new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
 new InputOption('with-dependencies', null, InputOption::VALUE_NONE, 'Add also all dependencies of whitelisted packages to the whitelist.'),
 new InputOption('verbose', 'v|vv|vvv', InputOption::VALUE_NONE, 'Shows more details including new commits pulled in when updating packages.'),
 new InputOption('optimize-autoloader', 'o', InputOption::VALUE_NONE, 'Optimize autoloader during autoloader dump.'),
 new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
 new InputOption('prefer-stable', null, InputOption::VALUE_NONE, 'Prefer stable versions of dependencies.'),
 new InputOption('prefer-lowest', null, InputOption::VALUE_NONE, 'Prefer lowest versions of dependencies.'),
 ))
 ->setHelp(<<<EOT
 The <info>update</info> command reads the composer.json file from the
 current directory, processes it, and updates, removes or installs all the
 dependencies.

 <info>php composer.phar update</info>

 To limit the update operation to a few packages, you can list the package(s)
 you want to update as such:

 <info>php composer.phar update vendor/package1 foo/mypackage [...]</info>

 You may also use an asterisk (*) pattern to limit the update operation to package(s)
 from a specific vendor:

 <info>php composer.phar update vendor/package1 foo/* [...]</info>
 EOT
 )
 ;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
 if ($input->getOption('no-custom-installers')) {
 $this->getIO()->writeError('<warning>You are using the deprecated option "no-custom-installers". Use "no-plugins" instead.</warning>');
 $input->setOption('no-plugins', true);
 }

 if ($input->getOption('dev')) {
 $this->getIO()->writeError('<warning>You are using the deprecated option "dev". Dev packages are installed by default now.</warning>');
 }

 $composer = $this->getComposer(true, $input->getOption('no-plugins'));
 $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
 $io = $this->getIO();

 $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'update', $input, $output);
 $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);

 $install = Installer::create($io, $composer);

 $preferSource = false;
 $preferDist = false;

 $config = $composer->getConfig();

 switch ($config->get('preferred-install')) {
 case 'source':
 $preferSource = true;
 break;
 case 'dist':
 $preferDist = true;
 break;
 case 'auto':
 default:

 break;
 }
 if ($input->getOption('prefer-source') || $input->getOption('prefer-dist')) {
 $preferSource = $input->getOption('prefer-source');
 $preferDist = $input->getOption('prefer-dist');
 }

 $optimize = $input->getOption('optimize-autoloader') || $config->get('optimize-autoloader') || $config->get('classmap-authoritative');

 $install
 ->setDryRun($input->getOption('dry-run'))
 ->setVerbose($input->getOption('verbose'))
 ->setPreferSource($preferSource)
 ->setPreferDist($preferDist)
 ->setDevMode(!$input->getOption('no-dev'))
 ->setDumpAutoloader(!$input->getOption('no-autoloader'))
 ->setRunScripts(!$input->getOption('no-scripts'))
 ->setOptimizeAutoloader($optimize)
 ->setUpdate(true)
 ->setUpdateWhitelist($input->getOption('lock') ? array('lock') : $input->getArgument('packages'))
 ->setWhitelistDependencies($input->getOption('with-dependencies'))
 ->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'))
 ->setPreferStable($input->getOption('prefer-stable'))
 ->setPreferLowest($input->getOption('prefer-lowest'))
 ;

 if ($input->getOption('no-plugins')) {
 $install->disablePlugins();
 }

 return $install->run();
 }
 }
 <?php











 namespace Composer\Command;

 use Composer\Factory;
 use Composer\Package\Loader\ValidatingArrayLoader;
 use Composer\Util\ConfigValidator;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;







 class ValidateCommand extends Command
 {



 protected function configure()
 {
 $this
 ->setName('validate')
 ->setDescription('Validates a composer.json and composer.lock')
 ->setDefinition(array(
 new InputOption('no-check-all', null, InputOption::VALUE_NONE, 'Do not make a complete validation'),
 new InputOption('no-check-lock', null, InputOption::VALUE_NONE, 'Do not check if lock file is up to date'),
 new InputOption('no-check-publish', null, InputOption::VALUE_NONE, 'Do not check for publish errors'),
 new InputArgument('file', InputArgument::OPTIONAL, 'path to composer.json file', './composer.json')
 ))
 ->setHelp(<<<EOT
 The validate command validates a given composer.json and composer.lock

 EOT
 );
 }







 protected function execute(InputInterface $input, OutputInterface $output)
 {
 $file = $input->getArgument('file');

 if (!file_exists($file)) {
 $this->getIO()->writeError('<error>' . $file . ' not found.</error>');

 return 1;
 }
 if (!is_readable($file)) {
 $this->getIO()->writeError('<error>' . $file . ' is not readable.</error>');

 return 1;
 }

 $validator = new ConfigValidator($this->getIO());
 $checkAll = $input->getOption('no-check-all') ? 0 : ValidatingArrayLoader::CHECK_ALL;
 $checkPublish = !$input->getOption('no-check-publish');
 list($errors, $publishErrors, $warnings) = $validator->validate($file, $checkAll);

 $checkLock = !$input->getOption('no-check-lock');

 $lockErrors = array();
 $composer = Factory::create($this->getIO(), $file);
 $locker = $composer->getLocker();
 if ($locker->isLocked() && !$locker->isFresh()) {
 $lockErrors[] = 'The lock file is not up to date with the latest changes in composer.json.';
 }


 if (!$errors && !$publishErrors && !$warnings) {
 $this->getIO()->write('<info>' . $file . ' is valid</info>');
 } elseif (!$errors && !$publishErrors) {
 $this->getIO()->writeError('<info>' . $file . ' is valid, but with a few warnings</info>');
 $this->getIO()->writeError('<warning>See https://getcomposer.org/doc/04-schema.md for details on the schema</warning>');
 } elseif (!$errors) {
 $this->getIO()->writeError('<info>' . $file . ' is valid for simple usage with composer but has</info>');
 $this->getIO()->writeError('<info>strict errors that make it unable to be published as a package:</info>');
 $this->getIO()->writeError('<warning>See https://getcomposer.org/doc/04-schema.md for details on the schema</warning>');
 } else {
 $this->getIO()->writeError('<error>' . $file . ' is invalid, the following errors/warnings were found:</error>');
 }

 $messages = array(
 'error' => $errors,
 'warning' => $warnings,
 );


 if ($checkPublish) {
 $messages['error'] = array_merge($messages['error'], $publishErrors);
 } else {
 $messages['warning'] = array_merge($messages['warning'], $publishErrors);
 }


 if ($checkLock) {
 $messages['error'] = array_merge($messages['error'], $lockErrors);
 } else {
 $messages['warning'] = array_merge($messages['warning'], $lockErrors);
 }

 foreach ($messages as $style => $msgs) {
 foreach ($msgs as $msg) {
 $this->getIO()->writeError('<' . $style . '>' . $msg . '</' . $style . '>');
 }
 }

 return $errors || ($publishErrors && $checkPublish) || ($lockErrors && $checkLock) ? 1 : 0;
 }
 }
 <?php











 namespace Composer;

 use Composer\Package\RootPackageInterface;
 use Composer\Package\Locker;
 use Composer\Repository\RepositoryManager;
 use Composer\Installer\InstallationManager;
 use Composer\Plugin\PluginManager;
 use Composer\Downloader\DownloadManager;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Autoload\AutoloadGenerator;






 class Composer
 {
 const VERSION = 'afd98b74f13b9def1b2447f16fd0bfd4d96dff94';
 const BRANCH_ALIAS_VERSION = '1.0-dev';
 const RELEASE_DATE = '2015-08-31 09:58:50';




 private $package;




 private $locker;




 private $repositoryManager;




 private $downloadManager;




 private $installationManager;




 private $pluginManager;




 private $config;




 private $eventDispatcher;




 private $autoloadGenerator;





 public function setPackage(RootPackageInterface $package)
 {
 $this->package = $package;
 }




 public function getPackage()
 {
 return $this->package;
 }




 public function setConfig(Config $config)
 {
 $this->config = $config;
 }




 public function getConfig()
 {
 return $this->config;
 }




 public function setLocker(Locker $locker)
 {
 $this->locker = $locker;
 }




 public function getLocker()
 {
 return $this->locker;
 }




 public function setRepositoryManager(RepositoryManager $manager)
 {
 $this->repositoryManager = $manager;
 }




 public function getRepositoryManager()
 {
 return $this->repositoryManager;
 }




 public function setDownloadManager(DownloadManager $manager)
 {
 $this->downloadManager = $manager;
 }




 public function getDownloadManager()
 {
 return $this->downloadManager;
 }




 public function setInstallationManager(InstallationManager $manager)
 {
 $this->installationManager = $manager;
 }




 public function getInstallationManager()
 {
 return $this->installationManager;
 }




 public function setPluginManager(PluginManager $manager)
 {
 $this->pluginManager = $manager;
 }




 public function getPluginManager()
 {
 return $this->pluginManager;
 }




 public function setEventDispatcher(EventDispatcher $eventDispatcher)
 {
 $this->eventDispatcher = $eventDispatcher;
 }




 public function getEventDispatcher()
 {
 return $this->eventDispatcher;
 }




 public function setAutoloadGenerator(AutoloadGenerator $autoloadGenerator)
 {
 $this->autoloadGenerator = $autoloadGenerator;
 }




 public function getAutoloadGenerator()
 {
 return $this->autoloadGenerator;
 }
 }
 <?php











 namespace Composer;

 use Composer\Config\ConfigSourceInterface;




 class Config
 {
 const RELATIVE_PATHS = 1;

 public static $defaultConfig = array(
 'process-timeout' => 300,
 'use-include-path' => false,
 'preferred-install' => 'auto',
 'notify-on-install' => true,
 'github-protocols' => array('git', 'https', 'ssh'),
 'vendor-dir' => 'vendor',
 'bin-dir' => '{$vendor-dir}/bin',
 'cache-dir' => '{$home}/cache',
 'cache-files-dir' => '{$cache-dir}/files',
 'cache-repo-dir' => '{$cache-dir}/repo',
 'cache-vcs-dir' => '{$cache-dir}/vcs',
 'cache-ttl' => 15552000, 
 'cache-files-ttl' => null, 
 'cache-files-maxsize' => '300MiB',
 'discard-changes' => false,
 'autoloader-suffix' => null,
 'optimize-autoloader' => false,
 'classmap-authoritative' => false,
 'prepend-autoloader' => true,
 'github-domains' => array('github.com'),
 'github-expose-hostname' => true,
 'store-auths' => 'prompt',
 'platform' => array(),
 'archive-format' => 'tar',
 'archive-dir' => '.',

 
 
 );

 public static $defaultRepositories = array(
 'packagist' => array(
 'type' => 'composer',
 'url' => 'https?://packagist.org',
 'allow_ssl_downgrade' => true,
 )
 );

 private $config;
 private $baseDir;
 private $repositories;
 private $configSource;
 private $authConfigSource;
 private $useEnvironment;




 public function __construct($useEnvironment = true, $baseDir = null)
 {

 $this->config = static::$defaultConfig;
 $this->repositories = static::$defaultRepositories;
 $this->useEnvironment = (bool) $useEnvironment;
 $this->baseDir = $baseDir;
 }

 public function setConfigSource(ConfigSourceInterface $source)
 {
 $this->configSource = $source;
 }

 public function getConfigSource()
 {
 return $this->configSource;
 }

 public function setAuthConfigSource(ConfigSourceInterface $source)
 {
 $this->authConfigSource = $source;
 }

 public function getAuthConfigSource()
 {
 return $this->authConfigSource;
 }






 public function merge($config)
 {

 if (!empty($config['config']) && is_array($config['config'])) {
 foreach ($config['config'] as $key => $val) {
 if (in_array($key, array('github-oauth', 'http-basic')) && isset($this->config[$key])) {
 $this->config[$key] = array_merge($this->config[$key], $val);
 } else {
 $this->config[$key] = $val;
 }
 }
 }

 if (!empty($config['repositories']) && is_array($config['repositories'])) {
 $this->repositories = array_reverse($this->repositories, true);
 $newRepos = array_reverse($config['repositories'], true);
 foreach ($newRepos as $name => $repository) {

 if (false === $repository) {
 unset($this->repositories[$name]);
 continue;
 }


 if (is_array($repository) && 1 === count($repository) && false === current($repository)) {
 unset($this->repositories[key($repository)]);
 continue;
 }


 if (is_int($name)) {
 $this->repositories[] = $repository;
 } else {
 $this->repositories[$name] = $repository;
 }
 }
 $this->repositories = array_reverse($this->repositories, true);
 }
 }




 public function getRepositories()
 {
 return $this->repositories;
 }









 public function get($key, $flags = 0)
 {
 switch ($key) {
 case 'vendor-dir':
 case 'bin-dir':
 case 'process-timeout':
 case 'cache-dir':
 case 'cache-files-dir':
 case 'cache-repo-dir':
 case 'cache-vcs-dir':

 $env = 'COMPOSER_' . strtoupper(strtr($key, '-', '_'));

 $val = rtrim($this->process($this->getComposerEnv($env) ?: $this->config[$key], $flags), '/\\');
 $val = preg_replace('#^(\$HOME|~)(/|$)#', rtrim(getenv('HOME') ?: getenv('USERPROFILE'), '/\\') . '/', $val);

 if (substr($key, -4) !== '-dir') {
 return $val;
 }

 return ($flags & self::RELATIVE_PATHS == 1) ? $val : $this->realpath($val);

 case 'cache-ttl':
 return (int) $this->config[$key];

 case 'cache-files-maxsize':
 if (!preg_match('/^\s*([0-9.]+)\s*(?:([kmg])(?:i?b)?)?\s*$/i', $this->config[$key], $matches)) {
 throw new \RuntimeException(
 "Could not parse the value of 'cache-files-maxsize': {$this->config[$key]}"
 );
 }
 $size = $matches[1];
 if (isset($matches[2])) {
 switch (strtolower($matches[2])) {
 case 'g':
 $size *= 1024;

 case 'm':
 $size *= 1024;

 case 'k':
 $size *= 1024;
 break;
 }
 }

 return $size;

 case 'cache-files-ttl':
 if (isset($this->config[$key])) {
 return (int) $this->config[$key];
 }

 return (int) $this->config['cache-ttl'];

 case 'home':
 return rtrim($this->process($this->config[$key], $flags), '/\\');

 case 'discard-changes':
 if ($env = $this->getComposerEnv('COMPOSER_DISCARD_CHANGES')) {
 if (!in_array($env, array('stash', 'true', 'false', '1', '0'), true)) {
 throw new \RuntimeException(
 "Invalid value for COMPOSER_DISCARD_CHANGES: {$env}. Expected 1, 0, true, false or stash"
 );
 }
 if ('stash' === $env) {
 return 'stash';
 }


 return $env !== 'false' && (bool) $env;
 }

 if (!in_array($this->config[$key], array(true, false, 'stash'), true)) {
 throw new \RuntimeException(
 "Invalid value for 'discard-changes': {$this->config[$key]}. Expected true, false or stash"
 );
 }

 return $this->config[$key];

 case 'github-protocols':
 if (reset($this->config['github-protocols']) === 'http') {
 throw new \RuntimeException('The http protocol for github is not available anymore, update your config\'s github-protocols to use "https", "git" or "ssh"');
 }

 return $this->config[$key];

 default:
 if (!isset($this->config[$key])) {
 return null;
 }

 return $this->process($this->config[$key], $flags);
 }
 }

 public function all($flags = 0)
 {
 $all = array(
 'repositories' => $this->getRepositories(),
 );
 foreach (array_keys($this->config) as $key) {
 $all['config'][$key] = $this->get($key, $flags);
 }

 return $all;
 }

 public function raw()
 {
 return array(
 'repositories' => $this->getRepositories(),
 'config' => $this->config,
 );
 }







 public function has($key)
 {
 return array_key_exists($key, $this->config);
 }








 private function process($value, $flags)
 {
 $config = $this;

 if (!is_string($value)) {
 return $value;
 }

 return preg_replace_callback('#\{\$(.+)\}#', function ($match) use ($config, $flags) {
 return $config->get($match[1], $flags);
 }, $value);
 }









 private function realpath($path)
 {
 if (substr($path, 0, 1) === '/' || substr($path, 1, 1) === ':') {
 return $path;
 }

 return $this->baseDir . '/' . $path;
 }










 private function getComposerEnv($var)
 {
 if ($this->useEnvironment) {
 return getenv($var);
 }

 return false;
 }
 }
 <?php











 namespace Composer\Config;







 interface ConfigSourceInterface
 {






 public function addRepository($name, $config);






 public function removeRepository($name);







 public function addConfigSetting($name, $value);






 public function removeConfigSetting($name);








 public function addLink($type, $name, $value);







 public function removeLink($type, $name);






 public function getName();
 }
 <?php











 namespace Composer\Config;

 use Composer\Json\JsonFile;
 use Composer\Json\JsonManipulator;







 class JsonConfigSource implements ConfigSourceInterface
 {



 private $file;




 private $authConfig;







 public function __construct(JsonFile $file, $authConfig = false)
 {
 $this->file = $file;
 $this->authConfig = $authConfig;
 }




 public function getName()
 {
 return $this->file->getPath();
 }




 public function addRepository($name, $config)
 {
 $this->manipulateJson('addRepository', $name, $config, function (&$config, $repo, $repoConfig) {
 $config['repositories'][$repo] = $repoConfig;
 });
 }




 public function removeRepository($name)
 {
 $this->manipulateJson('removeRepository', $name, function (&$config, $repo) {
 unset($config['repositories'][$repo]);
 });
 }




 public function addConfigSetting($name, $value)
 {
 $this->manipulateJson('addConfigSetting', $name, $value, function (&$config, $key, $val) {
 if (preg_match('{^(github-oauth|http-basic|platform)\.}', $key)) {
 list($key, $host) = explode('.', $key, 2);
 if ($this->authConfig) {
 $config[$key][$host] = $val;
 } else {
 $config['config'][$key][$host] = $val;
 }
 } else {
 $config['config'][$key] = $val;
 }
 });
 }




 public function removeConfigSetting($name)
 {
 $this->manipulateJson('removeConfigSetting', $name, function (&$config, $key) {
 if (preg_match('{^(github-oauth|http-basic|platform)\.}', $key)) {
 list($key, $host) = explode('.', $key, 2);
 if ($this->authConfig) {
 unset($config[$key][$host]);
 } else {
 unset($config['config'][$key][$host]);
 }
 } else {
 unset($config['config'][$key]);
 }
 });
 }




 public function addLink($type, $name, $value)
 {
 $this->manipulateJson('addLink', $type, $name, $value, function (&$config, $type, $name, $value) {
 $config[$type][$name] = $value;
 });
 }




 public function removeLink($type, $name)
 {
 $this->manipulateJson('removeSubNode', $type, $name, function (&$config, $type, $name) {
 unset($config[$type][$name]);
 });
 }

 protected function manipulateJson($method, $args, $fallback)
 {
 $args = func_get_args();

 array_shift($args);
 $fallback = array_pop($args);

 if ($this->file->exists()) {
 $contents = file_get_contents($this->file->getPath());
 } elseif ($this->authConfig) {
 $contents = "{\n}\n";
 } else {
 $contents = "{\n    \"config\": {\n    }\n}\n";
 }

 $manipulator = new JsonManipulator($contents);

 $newFile = !$this->file->exists();


 if ($this->authConfig && $method === 'addConfigSetting') {
 $method = 'addSubNode';
 list($mainNode, $name) = explode('.', $args[0], 2);
 $args = array($mainNode, $name, $args[1]);
 } elseif ($this->authConfig && $method === 'removeConfigSetting') {
 $method = 'removeSubNode';
 list($mainNode, $name) = explode('.', $args[0], 2);
 $args = array($mainNode, $name);
 }


 if (call_user_func_array(array($manipulator, $method), $args)) {
 file_put_contents($this->file->getPath(), $manipulator->getContents());
 } else {

 $config = $this->file->read();
 $this->arrayUnshiftRef($args, $config);
 call_user_func_array($fallback, $args);
 $this->file->write($config);
 }

 if ($newFile) {
 @chmod($this->file->getPath(), 0600);
 }
 }








 private function arrayUnshiftRef(&$array, &$value)
 {
 $return = array_unshift($array, '');
 $array[0] = &$value;

 return $return;
 }
 }
 <?php











 namespace Composer\Console;

 use Symfony\Component\Console\Application as BaseApplication;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\ConsoleOutputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Output\ConsoleOutput;
 use Symfony\Component\Console\Formatter\OutputFormatter;
 use Composer\Command;
 use Composer\Composer;
 use Composer\Factory;
 use Composer\IO\IOInterface;
 use Composer\IO\ConsoleIO;
 use Composer\Json\JsonValidationException;
 use Composer\Util\ErrorHandler;








 class Application extends BaseApplication
 {



 protected $composer;




 protected $io;

 private static $logo = '   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
 / /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
 \____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
 ';

 public function __construct()
 {
 if (function_exists('ini_set') && extension_loaded('xdebug')) {
 ini_set('xdebug.show_exception_trace', false);
 ini_set('xdebug.scream', false);
 }

 if (function_exists('date_default_timezone_set') && function_exists('date_default_timezone_get')) {
 date_default_timezone_set(@date_default_timezone_get());
 }

 parent::__construct('Composer', Composer::VERSION);
 }




 public function run(InputInterface $input = null, OutputInterface $output = null)
 {
 if (null === $output) {
 $styles = Factory::createAdditionalStyles();
 $formatter = new OutputFormatter(null, $styles);
 $output = new ConsoleOutput(ConsoleOutput::VERBOSITY_NORMAL, null, $formatter);
 }

 return parent::run($input, $output);
 }




 public function doRun(InputInterface $input, OutputInterface $output)
 {
 $this->io = new ConsoleIO($input, $output, $this->getHelperSet());
 ErrorHandler::register($this->io);

 if (PHP_VERSION_ID < 50302) {
 $this->getIO()->writeError('<warning>Composer only officially supports PHP 5.3.2 and above, you will most likely encounter problems with your PHP '.PHP_VERSION.', upgrading is strongly recommended.</warning>');
 }

 if (defined('COMPOSER_DEV_WARNING_TIME')) {
 $commandName = '';
 if ($name = $this->getCommandName($input)) {
 try {
 $commandName = $this->find($name)->getName();
 } catch (\InvalidArgumentException $e) {
 }
 }
 if ($commandName !== 'self-update' && $commandName !== 'selfupdate') {
 if (time() > COMPOSER_DEV_WARNING_TIME) {
 $this->getIO()->writeError(sprintf('<warning>Warning: This development build of composer is over 60 days old. It is recommended to update it by running "%s self-update" to get the latest version.</warning>', $_SERVER['PHP_SELF']));
 }
 }
 }

 if (getenv('COMPOSER_NO_INTERACTION')) {
 $input->setInteractive(false);
 }


 if ($newWorkDir = $this->getNewWorkingDir($input)) {
 $oldWorkingDir = getcwd();
 chdir($newWorkDir);
 if ($this->getIO()->isDebug() >= 4) {
 $this->getIO()->writeError('Changed CWD to ' . getcwd());
 }
 }


 $file = Factory::getComposerFile();
 if (is_file($file) && is_readable($file) && is_array($composer = json_decode(file_get_contents($file), true))) {
 if (isset($composer['scripts']) && is_array($composer['scripts'])) {
 foreach ($composer['scripts'] as $script => $dummy) {
 if (!defined('Composer\Script\ScriptEvents::'.str_replace('-', '_', strtoupper($script)))) {
 if ($this->has($script)) {
 $this->getIO()->writeError('<warning>A script named '.$script.' would override a native Composer function and has been skipped</warning>');
 } else {
 $this->add(new Command\ScriptAliasCommand($script));
 }
 }
 }
 }
 }

 if ($input->hasParameterOption('--profile')) {
 $startTime = microtime(true);
 $this->io->enableDebugging($startTime);
 }

 $result = parent::doRun($input, $output);

 if (isset($oldWorkingDir)) {
 chdir($oldWorkingDir);
 }

 if (isset($startTime)) {
 $this->getIO()->writeError('<info>Memory usage: '.round(memory_get_usage() / 1024 / 1024, 2).'MB (peak: '.round(memory_get_peak_usage() / 1024 / 1024, 2).'MB), time: '.round(microtime(true) - $startTime, 2).'s');
 }

 return $result;
 }






 private function getNewWorkingDir(InputInterface $input)
 {
 $workingDir = $input->getParameterOption(array('--working-dir', '-d'));
 if (false !== $workingDir && !is_dir($workingDir)) {
 throw new \RuntimeException('Invalid working directory specified.');
 }

 return $workingDir;
 }




 public function renderException($exception, $output)
 {
 try {
 $composer = $this->getComposer(false, true);
 if ($composer) {
 $config = $composer->getConfig();

 $minSpaceFree = 1024 * 1024;
 if ((($df = @disk_free_space($dir = $config->get('home'))) !== false && $df < $minSpaceFree)
 || (($df = @disk_free_space($dir = $config->get('vendor-dir'))) !== false && $df < $minSpaceFree)
 || (($df = @disk_free_space($dir = sys_get_temp_dir())) !== false && $df < $minSpaceFree)
 ) {
 $this->getIO()->writeError('<error>The disk hosting '.$dir.' is full, this may be the cause of the following exception</error>');
 }
 }
 } catch (\Exception $e) {
 }

 if (defined('PHP_WINDOWS_VERSION_BUILD') && false !== strpos($exception->getMessage(), 'The system cannot find the path specified')) {
 $this->getIO()->writeError('<error>The following exception may be caused by a stale entry in your cmd.exe AutoRun</error>');
 $this->getIO()->writeError('<error>Check https://getcomposer.org/doc/articles/troubleshooting.md#-the-system-cannot-find-the-path-specified-windows- for details</error>');
 }

 if (false !== strpos($exception->getMessage(), 'fork failed - Cannot allocate memory')) {
 $this->getIO()->writeError('<error>The following exception is caused by a lack of memory and not having swap configured</error>');
 $this->getIO()->writeError('<error>Check https://getcomposer.org/doc/articles/troubleshooting.md#proc-open-fork-failed-errors for details</error>');
 }

 if ($output instanceof ConsoleOutputInterface) {
 parent::renderException($exception, $output->getErrorOutput());
 } else {
 parent::renderException($exception, $output);
 }
 }







 public function getComposer($required = true, $disablePlugins = false)
 {
 if (null === $this->composer) {
 try {
 $this->composer = Factory::create($this->io, null, $disablePlugins);
 } catch (\InvalidArgumentException $e) {
 if ($required) {
 $this->io->writeError($e->getMessage());
 exit(1);
 }
 } catch (JsonValidationException $e) {
 $errors = ' - ' . implode(PHP_EOL . ' - ', $e->getErrors());
 $message = $e->getMessage() . ':' . PHP_EOL . $errors;
 throw new JsonValidationException($message);
 }
 }

 return $this->composer;
 }




 public function resetComposer()
 {
 $this->composer = null;
 }




 public function getIO()
 {
 return $this->io;
 }

 public function getHelp()
 {
 return self::$logo . parent::getHelp();
 }




 protected function getDefaultCommands()
 {
 $commands = parent::getDefaultCommands();
 $commands[] = new Command\AboutCommand();
 $commands[] = new Command\ConfigCommand();
 $commands[] = new Command\DependsCommand();
 $commands[] = new Command\InitCommand();
 $commands[] = new Command\InstallCommand();
 $commands[] = new Command\CreateProjectCommand();
 $commands[] = new Command\UpdateCommand();
 $commands[] = new Command\SearchCommand();
 $commands[] = new Command\ValidateCommand();
 $commands[] = new Command\ShowCommand();
 $commands[] = new Command\SuggestsCommand();
 $commands[] = new Command\RequireCommand();
 $commands[] = new Command\DumpAutoloadCommand();
 $commands[] = new Command\StatusCommand();
 $commands[] = new Command\ArchiveCommand();
 $commands[] = new Command\DiagnoseCommand();
 $commands[] = new Command\RunScriptCommand();
 $commands[] = new Command\LicensesCommand();
 $commands[] = new Command\GlobalCommand();
 $commands[] = new Command\ClearCacheCommand();
 $commands[] = new Command\RemoveCommand();
 $commands[] = new Command\HomeCommand();

 if ('phar:' === substr(__FILE__, 0, 5)) {
 $commands[] = new Command\SelfUpdateCommand();
 }

 return $commands;
 }




 public function getLongVersion()
 {
 if (Composer::BRANCH_ALIAS_VERSION) {
 return sprintf(
 '<info>%s</info> version <comment>%s (%s)</comment> %s',
 $this->getName(),
 Composer::BRANCH_ALIAS_VERSION,
 $this->getVersion(),
 Composer::RELEASE_DATE
 );
 }

 return parent::getLongVersion() . ' ' . Composer::RELEASE_DATE;
 }




 protected function getDefaultInputDefinition()
 {
 $definition = parent::getDefaultInputDefinition();
 $definition->addOption(new InputOption('--profile', null, InputOption::VALUE_NONE, 'Display timing and memory usage information'));
 $definition->addOption(new InputOption('--working-dir', '-d', InputOption::VALUE_REQUIRED, 'If specified, use the given directory as working directory.'));

 return $definition;
 }
 }
 <?php











 namespace Composer\Console;

 use Symfony\Component\Console\Formatter\OutputFormatter;




 class HtmlOutputFormatter extends OutputFormatter
 {
 private static $availableForegroundColors = array(
 30 => 'black',
 31 => 'red',
 32 => 'green',
 33 => 'yellow',
 34 => 'blue',
 35 => 'magenta',
 36 => 'cyan',
 37 => 'white'
 );
 private static $availableBackgroundColors = array(
 40 => 'black',
 41 => 'red',
 42 => 'green',
 43 => 'yellow',
 44 => 'blue',
 45 => 'magenta',
 46 => 'cyan',
 47 => 'white'
 );
 private static $availableOptions = array(
 1 => 'bold',
 4 => 'underscore',

 
 
 );




 public function __construct(array $styles = array())
 {
 parent::__construct(true, $styles);
 }

 public function format($message)
 {
 $formatted = parent::format($message);

 $clearEscapeCodes = '(?:39|49|0|22|24|25|27|28)';

 return preg_replace_callback("{\033\[([0-9;]+)m(.*?)\033\[(?:".$clearEscapeCodes.";)*?".$clearEscapeCodes."m}s", array($this, 'formatHtml'), $formatted);
 }

 private function formatHtml($matches)
 {
 $out = '<span style="';
 foreach (explode(';', $matches[1]) as $code) {
 if (isset(self::$availableForegroundColors[$code])) {
 $out .= 'color:'.self::$availableForegroundColors[$code].';';
 } elseif (isset(self::$availableBackgroundColors[$code])) {
 $out .= 'background-color:'.self::$availableBackgroundColors[$code].';';
 } elseif (isset(self::$availableOptions[$code])) {
 switch (self::$availableOptions[$code]) {
 case 'bold':
 $out .= 'font-weight:bold;';
 break;

 case 'underscore':
 $out .= 'text-decoration:underline;';
 break;
 }
 }
 }

 return $out.'">'.$matches[2].'</span>';
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class DebugSolver extends Solver
 {
 protected function printDecisionMap()
 {
 echo "\nDecisionMap: \n";
 foreach ($this->decisionMap as $packageId => $level) {
 if ($packageId === 0) {
 continue;
 }
 if ($level > 0) {
 echo '    +' . $this->pool->packageById($packageId)."\n";
 } elseif ($level < 0) {
 echo '    -' . $this->pool->packageById($packageId)."\n";
 } else {
 echo '    ?' . $this->pool->packageById($packageId)."\n";
 }
 }
 echo "\n";
 }

 protected function printDecisionQueue()
 {
 echo "DecisionQueue: \n";
 foreach ($this->decisionQueue as $i => $literal) {
 echo '    ' . $this->pool->literalToString($literal) . ' ' . $this->decisionQueueWhy[$i]." level ".$this->decisionMap[abs($literal)]."\n";
 }
 echo "\n";
 }

 protected function printWatches()
 {
 echo "\nWatches:\n";
 foreach ($this->watches as $literalId => $watch) {
 echo '  '.$this->literalFromId($literalId)."\n";
 $queue = array(array('    ', $watch));

 while (!empty($queue)) {
 list($indent, $watch) = array_pop($queue);

 echo $indent.$watch;

 if ($watch) {
 echo ' [id='.$watch->getId().',watch1='.$this->literalFromId($watch->watch1).',watch2='.$this->literalFromId($watch->watch2)."]";
 }

 echo "\n";

 if ($watch && ($watch->next1 == $watch || $watch->next2 == $watch)) {
 if ($watch->next1 == $watch) {
 echo $indent."    1 *RECURSION*";
 }
 if ($watch->next2 == $watch) {
 echo $indent."    2 *RECURSION*";
 }
 } elseif ($watch && ($watch->next1 || $watch->next2)) {
 $indent = str_replace(array('1', '2'), ' ', $indent);

 array_push($queue, array($indent.'    2 ', $watch->next2));
 array_push($queue, array($indent.'    1 ', $watch->next1));
 }
 }

 echo "\n";
 }
 }
 }
 <?php











 namespace Composer\DependencyResolver;






 class Decisions implements \Iterator, \Countable
 {
 const DECISION_LITERAL = 0;
 const DECISION_REASON = 1;

 protected $pool;
 protected $decisionMap;
 protected $decisionQueue = array();

 public function __construct($pool)
 {
 $this->pool = $pool;
 $this->decisionMap = array();
 }

 public function decide($literal, $level, $why)
 {
 $this->addDecision($literal, $level);
 $this->decisionQueue[] = array(
 self::DECISION_LITERAL => $literal,
 self::DECISION_REASON => $why,
 );
 }

 public function satisfy($literal)
 {
 $packageId = abs($literal);

 return (
 $literal > 0 && isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0 ||
 $literal < 0 && isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] < 0
 );
 }

 public function conflict($literal)
 {
 $packageId = abs($literal);

 return (
 (isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0 && $literal < 0) ||
 (isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] < 0 && $literal > 0)
 );
 }

 public function decided($literalOrPackageId)
 {
 return !empty($this->decisionMap[abs($literalOrPackageId)]);
 }

 public function undecided($literalOrPackageId)
 {
 return empty($this->decisionMap[abs($literalOrPackageId)]);
 }

 public function decidedInstall($literalOrPackageId)
 {
 $packageId = abs($literalOrPackageId);

 return isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0;
 }

 public function decisionLevel($literalOrPackageId)
 {
 $packageId = abs($literalOrPackageId);
 if (isset($this->decisionMap[$packageId])) {
 return abs($this->decisionMap[$packageId]);
 }

 return 0;
 }

 public function decisionRule($literalOrPackageId)
 {
 $packageId = abs($literalOrPackageId);

 foreach ($this->decisionQueue as $i => $decision) {
 if ($packageId === abs($decision[self::DECISION_LITERAL])) {
 return $decision[self::DECISION_REASON];
 }
 }

 return null;
 }

 public function atOffset($queueOffset)
 {
 return $this->decisionQueue[$queueOffset];
 }

 public function validOffset($queueOffset)
 {
 return $queueOffset >= 0 && $queueOffset < count($this->decisionQueue);
 }

 public function lastReason()
 {
 return $this->decisionQueue[count($this->decisionQueue) - 1][self::DECISION_REASON];
 }

 public function lastLiteral()
 {
 return $this->decisionQueue[count($this->decisionQueue) - 1][self::DECISION_LITERAL];
 }

 public function reset()
 {
 while ($decision = array_pop($this->decisionQueue)) {
 $this->decisionMap[abs($decision[self::DECISION_LITERAL])] = 0;
 }
 }

 public function resetToOffset($offset)
 {
 while (count($this->decisionQueue) > $offset + 1) {
 $decision = array_pop($this->decisionQueue);
 $this->decisionMap[abs($decision[self::DECISION_LITERAL])] = 0;
 }
 }

 public function revertLast()
 {
 $this->decisionMap[abs($this->lastLiteral())] = 0;
 array_pop($this->decisionQueue);
 }

 public function count()
 {
 return count($this->decisionQueue);
 }

 public function rewind()
 {
 end($this->decisionQueue);
 }

 public function current()
 {
 return current($this->decisionQueue);
 }

 public function key()
 {
 return key($this->decisionQueue);
 }

 public function next()
 {
 return prev($this->decisionQueue);
 }

 public function valid()
 {
 return false !== current($this->decisionQueue);
 }

 public function isEmpty()
 {
 return count($this->decisionQueue) === 0;
 }

 protected function addDecision($literal, $level)
 {
 $packageId = abs($literal);

 $previousDecision = isset($this->decisionMap[$packageId]) ? $this->decisionMap[$packageId] : null;
 if ($previousDecision != 0) {
 $literalString = $this->pool->literalToString($literal);
 $package = $this->pool->literalToPackage($literal);
 throw new SolverBugException(
 "Trying to decide $literalString on level $level, even though $package was previously decided as ".(int) $previousDecision."."
 );
 }

 if ($literal > 0) {
 $this->decisionMap[$packageId] = $level;
 } else {
 $this->decisionMap[$packageId] = -$level;
 }
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\PackageInterface;
 use Composer\Package\AliasPackage;
 use Composer\Package\BasePackage;
 use Composer\Package\LinkConstraint\VersionConstraint;





 class DefaultPolicy implements PolicyInterface
 {
 private $preferStable;
 private $preferLowest;

 public function __construct($preferStable = false, $preferLowest = false)
 {
 $this->preferStable = $preferStable;
 $this->preferLowest = $preferLowest;
 }

 public function versionCompare(PackageInterface $a, PackageInterface $b, $operator)
 {
 if ($this->preferStable && ($stabA = $a->getStability()) !== ($stabB = $b->getStability())) {
 return BasePackage::$stabilities[$stabA] < BasePackage::$stabilities[$stabB];
 }

 $constraint = new VersionConstraint($operator, $b->getVersion());
 $version = new VersionConstraint('==', $a->getVersion());

 return $constraint->matchSpecific($version, true);
 }

 public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package, $mustMatchName = false)
 {
 $packages = array();

 foreach ($pool->whatProvides($package->getName(), null, $mustMatchName) as $candidate) {
 if ($candidate !== $package) {
 $packages[] = $candidate;
 }
 }

 return $packages;
 }

 public function getPriority(Pool $pool, PackageInterface $package)
 {
 return $pool->getPriority($package->getRepository());
 }




 public function selectPreferedPackages(Pool $pool, array $installedMap, array $literals, $requiredPackage = null)
 {
 return $this->selectPreferredPackages($pool, $installedMap, $literals, $requiredPackage);
 }

 public function selectPreferredPackages(Pool $pool, array $installedMap, array $literals, $requiredPackage = null)
 {
 $packages = $this->groupLiteralsByNamePreferInstalled($pool, $installedMap, $literals);

 foreach ($packages as &$literals) {
 $policy = $this;
 usort($literals, function ($a, $b) use ($policy, $pool, $installedMap, $requiredPackage) {
 return $policy->compareByPriorityPreferInstalled($pool, $installedMap, $pool->literalToPackage($a), $pool->literalToPackage($b), $requiredPackage, true);
 });
 }

 foreach ($packages as &$literals) {
 $literals = $this->pruneToHighestPriorityOrInstalled($pool, $installedMap, $literals);

 $literals = $this->pruneToBestVersion($pool, $literals);

 $literals = $this->pruneRemoteAliases($pool, $literals);
 }

 $selected = call_user_func_array('array_merge', $packages);


 usort($selected, function ($a, $b) use ($policy, $pool, $installedMap, $requiredPackage) {
 return $policy->compareByPriorityPreferInstalled($pool, $installedMap, $pool->literalToPackage($a), $pool->literalToPackage($b), $requiredPackage);
 });

 return $selected;
 }

 protected function groupLiteralsByNamePreferInstalled(Pool $pool, array $installedMap, $literals)
 {
 $packages = array();
 foreach ($literals as $literal) {
 $packageName = $pool->literalToPackage($literal)->getName();

 if (!isset($packages[$packageName])) {
 $packages[$packageName] = array();
 }

 if (isset($installedMap[abs($literal)])) {
 array_unshift($packages[$packageName], $literal);
 } else {
 $packages[$packageName][] = $literal;
 }
 }

 return $packages;
 }




 public function compareByPriorityPreferInstalled(Pool $pool, array $installedMap, PackageInterface $a, PackageInterface $b, $requiredPackage = null, $ignoreReplace = false)
 {
 if ($a->getRepository() === $b->getRepository()) {

 if ($a->getName() === $b->getName()) {
 $aAliased = $a instanceof AliasPackage;
 $bAliased = $b instanceof AliasPackage;
 if ($aAliased && !$bAliased) {
 return -1; 
 }
 if (!$aAliased && $bAliased) {
 return 1; 
 }
 }

 if (!$ignoreReplace) {

 if ($this->replaces($a, $b)) {
 return 1; 
 }
 if ($this->replaces($b, $a)) {
 return -1; 
 }


 
 if ($requiredPackage && false !== ($pos = strpos($requiredPackage, '/'))) {
 $requiredVendor = substr($requiredPackage, 0, $pos);

 $aIsSameVendor = substr($a->getName(), 0, $pos) === $requiredVendor;
 $bIsSameVendor = substr($b->getName(), 0, $pos) === $requiredVendor;

 if ($bIsSameVendor !== $aIsSameVendor) {
 return $aIsSameVendor ? -1 : 1;
 }
 }
 }


 if ($a->id === $b->id) {
 return 0;
 }

 return ($a->id < $b->id) ? -1 : 1;
 }

 if (isset($installedMap[$a->id])) {
 return -1;
 }

 if (isset($installedMap[$b->id])) {
 return 1;
 }

 return ($this->getPriority($pool, $a) > $this->getPriority($pool, $b)) ? -1 : 1;
 }











 protected function replaces(PackageInterface $source, PackageInterface $target)
 {
 foreach ($source->getReplaces() as $link) {
 if ($link->getTarget() === $target->getName()


 ) {
 return true;
 }
 }

 return false;
 }

 protected function pruneToBestVersion(Pool $pool, $literals)
 {
 $operator = $this->preferLowest ? '<' : '>';
 $bestLiterals = array($literals[0]);
 $bestPackage = $pool->literalToPackage($literals[0]);
 foreach ($literals as $i => $literal) {
 if (0 === $i) {
 continue;
 }

 $package = $pool->literalToPackage($literal);

 if ($this->versionCompare($package, $bestPackage, $operator)) {
 $bestPackage = $package;
 $bestLiterals = array($literal);
 } elseif ($this->versionCompare($package, $bestPackage, '==')) {
 $bestLiterals[] = $literal;
 }
 }

 return $bestLiterals;
 }




 protected function pruneToHighestPriorityOrInstalled(Pool $pool, array $installedMap, array $literals)
 {
 $selected = array();

 $priority = null;

 foreach ($literals as $literal) {
 $package = $pool->literalToPackage($literal);

 if (isset($installedMap[$package->id])) {
 $selected[] = $literal;
 continue;
 }

 if (null === $priority) {
 $priority = $this->getPriority($pool, $package);
 }

 if ($this->getPriority($pool, $package) != $priority) {
 break;
 }

 $selected[] = $literal;
 }

 return $selected;
 }






 protected function pruneRemoteAliases(Pool $pool, array $literals)
 {
 $hasLocalAlias = false;

 foreach ($literals as $literal) {
 $package = $pool->literalToPackage($literal);

 if ($package instanceof AliasPackage && $package->isRootPackageAlias()) {
 $hasLocalAlias = true;
 break;
 }
 }

 if (!$hasLocalAlias) {
 return $literals;
 }

 $selected = array();
 foreach ($literals as $literal) {
 $package = $pool->literalToPackage($literal);

 if ($package instanceof AliasPackage && $package->isRootPackageAlias()) {
 $selected[] = $literal;
 }
 }

 return $selected;
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\PackageInterface;






 class InstallOperation extends SolverOperation
 {
 protected $package;







 public function __construct(PackageInterface $package, $reason = null)
 {
 parent::__construct($reason);

 $this->package = $package;
 }






 public function getPackage()
 {
 return $this->package;
 }






 public function getJobType()
 {
 return 'install';
 }




 public function __toString()
 {
 return 'Installing '.$this->package->getPrettyName().' ('.$this->formatVersion($this->package).')';
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\AliasPackage;
 use Composer\Package\PackageInterface;






 class MarkAliasInstalledOperation extends SolverOperation
 {
 protected $package;







 public function __construct(AliasPackage $package, $reason = null)
 {
 parent::__construct($reason);

 $this->package = $package;
 }






 public function getPackage()
 {
 return $this->package;
 }






 public function getJobType()
 {
 return 'markAliasInstalled';
 }




 public function __toString()
 {
 return 'Marking '.$this->package->getPrettyName().' ('.$this->formatVersion($this->package).') as installed, alias of '.$this->package->getAliasOf()->getPrettyName().' ('.$this->formatVersion($this->package->getAliasOf()).')';
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\AliasPackage;
 use Composer\Package\PackageInterface;






 class MarkAliasUninstalledOperation extends SolverOperation
 {
 protected $package;







 public function __construct(AliasPackage $package, $reason = null)
 {
 parent::__construct($reason);

 $this->package = $package;
 }






 public function getPackage()
 {
 return $this->package;
 }






 public function getJobType()
 {
 return 'markAliasUninstalled';
 }




 public function __toString()
 {
 return 'Marking '.$this->package->getPrettyName().' ('.$this->formatVersion($this->package).') as uninstalled, alias of '.$this->package->getAliasOf()->getPrettyName().' ('.$this->formatVersion($this->package->getAliasOf()).')';
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;






 interface OperationInterface
 {





 public function getJobType();






 public function getReason();






 public function __toString();
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\PackageInterface;






 abstract class SolverOperation implements OperationInterface
 {
 protected $reason;






 public function __construct($reason = null)
 {
 $this->reason = $reason;
 }






 public function getReason()
 {
 return $this->reason;
 }

 protected function formatVersion(PackageInterface $package)
 {
 return $package->getFullPrettyVersion();
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\PackageInterface;






 class UninstallOperation extends SolverOperation
 {
 protected $package;







 public function __construct(PackageInterface $package, $reason = null)
 {
 parent::__construct($reason);

 $this->package = $package;
 }






 public function getPackage()
 {
 return $this->package;
 }






 public function getJobType()
 {
 return 'uninstall';
 }




 public function __toString()
 {
 return 'Uninstalling '.$this->package->getPrettyName().' ('.$this->formatVersion($this->package).')';
 }
 }
 <?php











 namespace Composer\DependencyResolver\Operation;

 use Composer\Package\PackageInterface;






 class UpdateOperation extends SolverOperation
 {
 protected $initialPackage;
 protected $targetPackage;








 public function __construct(PackageInterface $initial, PackageInterface $target, $reason = null)
 {
 parent::__construct($reason);

 $this->initialPackage = $initial;
 $this->targetPackage = $target;
 }






 public function getInitialPackage()
 {
 return $this->initialPackage;
 }






 public function getTargetPackage()
 {
 return $this->targetPackage;
 }






 public function getJobType()
 {
 return 'update';
 }




 public function __toString()
 {
 return 'Updating '.$this->initialPackage->getPrettyName().' ('.$this->formatVersion($this->initialPackage).') to '.
 $this->targetPackage->getPrettyName(). ' ('.$this->formatVersion($this->targetPackage).')';
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\PackageInterface;




 interface PolicyInterface
 {
 public function versionCompare(PackageInterface $a, PackageInterface $b, $operator);
 public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package);
 public function selectPreferredPackages(Pool $pool, array $installedMap, array $literals);
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\BasePackage;
 use Composer\Package\AliasPackage;
 use Composer\Package\Version\VersionParser;
 use Composer\Package\LinkConstraint\LinkConstraintInterface;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Package\LinkConstraint\EmptyConstraint;
 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\ComposerRepository;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Repository\PlatformRepository;
 use Composer\Package\PackageInterface;







 class Pool implements \Countable
 {
 const MATCH_NAME = -1;
 const MATCH_NONE = 0;
 const MATCH = 1;
 const MATCH_PROVIDE = 2;
 const MATCH_REPLACE = 3;
 const MATCH_FILTERED = 4;

 protected $repositories = array();
 protected $providerRepos = array();
 protected $packages = array();
 protected $packageByName = array();
 protected $packageByExactName = array();
 protected $acceptableStabilities;
 protected $stabilityFlags;
 protected $versionParser;
 protected $providerCache = array();
 protected $filterRequires;
 protected $whitelist = null;
 protected $id = 1;

 public function __construct($minimumStability = 'stable', array $stabilityFlags = array(), array $filterRequires = array())
 {
 $this->versionParser = new VersionParser;
 $this->acceptableStabilities = array();
 foreach (BasePackage::$stabilities as $stability => $value) {
 if ($value <= BasePackage::$stabilities[$minimumStability]) {
 $this->acceptableStabilities[$stability] = $value;
 }
 }
 $this->stabilityFlags = $stabilityFlags;
 $this->filterRequires = $filterRequires;
 foreach ($filterRequires as $name => $constraint) {
 if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $name)) {
 unset($this->filterRequires[$name]);
 }
 }
 }

 public function setWhitelist($whitelist)
 {
 $this->whitelist = $whitelist;
 $this->providerCache = array();
 }







 public function addRepository(RepositoryInterface $repo, $rootAliases = array())
 {
 if ($repo instanceof CompositeRepository) {
 $repos = $repo->getRepositories();
 } else {
 $repos = array($repo);
 }

 foreach ($repos as $repo) {
 $this->repositories[] = $repo;

 $exempt = $repo instanceof PlatformRepository || $repo instanceof InstalledRepositoryInterface;

 if ($repo instanceof ComposerRepository && $repo->hasProviders()) {
 $this->providerRepos[] = $repo;
 $repo->setRootAliases($rootAliases);
 $repo->resetPackageIds();
 } else {
 foreach ($repo->getPackages() as $package) {
 $names = $package->getNames();
 $stability = $package->getStability();
 if ($exempt || $this->isPackageAcceptable($names, $stability)) {
 $package->setId($this->id++);
 $this->packages[] = $package;
 $this->packageByExactName[$package->getName()][$package->id] = $package;

 foreach ($names as $provided) {
 $this->packageByName[$provided][] = $package;
 }


 $name = $package->getName();
 if (isset($rootAliases[$name][$package->getVersion()])) {
 $alias = $rootAliases[$name][$package->getVersion()];
 if ($package instanceof AliasPackage) {
 $package = $package->getAliasOf();
 }
 $aliasPackage = new AliasPackage($package, $alias['alias_normalized'], $alias['alias']);
 $aliasPackage->setRootPackageAlias(true);
 $aliasPackage->setId($this->id++);

 $package->getRepository()->addPackage($aliasPackage);
 $this->packages[] = $aliasPackage;
 $this->packageByExactName[$aliasPackage->getName()][$aliasPackage->id] = $aliasPackage;

 foreach ($aliasPackage->getNames() as $name) {
 $this->packageByName[$name][] = $aliasPackage;
 }
 }
 }
 }
 }
 }
 }

 public function getPriority(RepositoryInterface $repo)
 {
 $priority = array_search($repo, $this->repositories, true);

 if (false === $priority) {
 throw new \RuntimeException("Could not determine repository priority. The repository was not registered in the pool.");
 }

 return -$priority;
 }







 public function packageById($id)
 {
 return $this->packages[$id - 1];
 }




 public function count()
 {
 return count($this->packages);
 }











 public function whatProvides($name, LinkConstraintInterface $constraint = null, $mustMatchName = false)
 {
 $key = ((int) $mustMatchName).$constraint;
 if (isset($this->providerCache[$name][$key])) {
 return $this->providerCache[$name][$key];
 }

 return $this->providerCache[$name][$key] = $this->computeWhatProvides($name, $constraint, $mustMatchName);
 }




 private function computeWhatProvides($name, $constraint, $mustMatchName = false)
 {
 $candidates = array();

 foreach ($this->providerRepos as $repo) {
 foreach ($repo->whatProvides($this, $name) as $candidate) {
 $candidates[] = $candidate;
 if ($candidate->id < 1) {
 $candidate->setId($this->id++);
 $this->packages[$this->id - 2] = $candidate;
 }
 }
 }

 if ($mustMatchName) {
 $candidates = array_filter($candidates, function ($candidate) use ($name) {
 return $candidate->getName() == $name;
 });
 if (isset($this->packageByExactName[$name])) {
 $candidates = array_merge($candidates, $this->packageByExactName[$name]);
 }
 } elseif (isset($this->packageByName[$name])) {
 $candidates = array_merge($candidates, $this->packageByName[$name]);
 }

 $matches = $provideMatches = array();
 $nameMatch = false;

 foreach ($candidates as $candidate) {
 $aliasOfCandidate = null;


 
 if ($candidate instanceof AliasPackage) {
 $aliasOfCandidate = $candidate->getAliasOf();
 }

 if ($this->whitelist !== null && (
 (!($candidate instanceof AliasPackage) && !isset($this->whitelist[$candidate->id])) ||
 ($candidate instanceof AliasPackage && !isset($this->whitelist[$aliasOfCandidate->id]))
 )) {
 continue;
 }
 switch ($this->match($candidate, $name, $constraint)) {
 case self::MATCH_NONE:
 break;

 case self::MATCH_NAME:
 $nameMatch = true;
 break;

 case self::MATCH:
 $nameMatch = true;
 $matches[] = $candidate;
 break;

 case self::MATCH_PROVIDE:
 $provideMatches[] = $candidate;
 break;

 case self::MATCH_REPLACE:
 $matches[] = $candidate;
 break;

 case self::MATCH_FILTERED:
 break;

 default:
 throw new \UnexpectedValueException('Unexpected match type');
 }
 }


 if ($nameMatch) {
 return $matches;
 }

 return array_merge($matches, $provideMatches);
 }

 public function literalToPackage($literal)
 {
 $packageId = abs($literal);

 return $this->packageById($packageId);
 }

 public function literalToString($literal)
 {
 return ($literal > 0 ? '+' : '-') . $this->literalToPackage($literal);
 }

 public function literalToPrettyString($literal, $installedMap)
 {
 $package = $this->literalToPackage($literal);

 if (isset($installedMap[$package->id])) {
 $prefix = ($literal > 0 ? 'keep' : 'remove');
 } else {
 $prefix = ($literal > 0 ? 'install' : 'don\'t install');
 }

 return $prefix.' '.$package->getPrettyString();
 }

 public function isPackageAcceptable($name, $stability)
 {
 foreach ((array) $name as $n) {

 if (!isset($this->stabilityFlags[$n]) && isset($this->acceptableStabilities[$stability])) {
 return true;
 }


 if (isset($this->stabilityFlags[$n]) && BasePackage::$stabilities[$stability] <= $this->stabilityFlags[$n]) {
 return true;
 }
 }

 return false;
 }










 private function match($candidate, $name, LinkConstraintInterface $constraint = null)
 {
 $candidateName = $candidate->getName();
 $candidateVersion = $candidate->getVersion();
 $isDev = $candidate->getStability() === 'dev';
 $isAlias = $candidate instanceof AliasPackage;

 if (!$isDev && !$isAlias && isset($this->filterRequires[$name])) {
 $requireFilter = $this->filterRequires[$name];
 } else {
 $requireFilter = new EmptyConstraint;
 }

 if ($candidateName === $name) {
 $pkgConstraint = new VersionConstraint('==', $candidateVersion);

 if ($constraint === null || $constraint->matches($pkgConstraint)) {
 return $requireFilter->matches($pkgConstraint) ? self::MATCH : self::MATCH_FILTERED;
 }

 return self::MATCH_NAME;
 }

 $provides = $candidate->getProvides();
 $replaces = $candidate->getReplaces();


 if (isset($replaces[0]) || isset($provides[0])) {
 foreach ($provides as $link) {
 if ($link->getTarget() === $name && ($constraint === null || $constraint->matches($link->getConstraint()))) {
 return $requireFilter->matches($link->getConstraint()) ? self::MATCH_PROVIDE : self::MATCH_FILTERED;
 }
 }

 foreach ($replaces as $link) {
 if ($link->getTarget() === $name && ($constraint === null || $constraint->matches($link->getConstraint()))) {
 return $requireFilter->matches($link->getConstraint()) ? self::MATCH_REPLACE : self::MATCH_FILTERED;
 }
 }

 return self::MATCH_NONE;
 }

 if (isset($provides[$name]) && ($constraint === null || $constraint->matches($provides[$name]->getConstraint()))) {
 return $requireFilter->matches($provides[$name]->getConstraint()) ? self::MATCH_PROVIDE : self::MATCH_FILTERED;
 }

 if (isset($replaces[$name]) && ($constraint === null || $constraint->matches($replaces[$name]->getConstraint()))) {
 return $requireFilter->matches($replaces[$name]->getConstraint()) ? self::MATCH_REPLACE : self::MATCH_FILTERED;
 }

 return self::MATCH_NONE;
 }
 }
 <?php











 namespace Composer\DependencyResolver;






 class Problem
 {




 protected $reasonSeen;





 protected $reasons = array();

 protected $section = 0;

 protected $pool;

 public function __construct(Pool $pool)
 {
 $this->pool = $pool;
 }






 public function addRule(Rule $rule)
 {
 $this->addReason(spl_object_hash($rule), array(
 'rule' => $rule,
 'job' => $rule->getJob(),
 ));
 }






 public function getReasons()
 {
 return $this->reasons;
 }







 public function getPrettyString(array $installedMap = array())
 {
 $reasons = call_user_func_array('array_merge', array_reverse($this->reasons));

 if (count($reasons) === 1) {
 reset($reasons);
 $reason = current($reasons);

 $rule = $reason['rule'];
 $job = $reason['job'];

 if (isset($job['constraint'])) {
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 } else {
 $packages = array();
 }

 if ($job && $job['cmd'] === 'install' && empty($packages)) {


 if ($job['packageName'] === 'php' || $job['packageName'] === 'php-64bit' || $job['packageName'] === 'hhvm') {
 $available = $this->pool->whatProvides($job['packageName']);
 $version = count($available) ? $available[0]->getPrettyVersion() : phpversion();

 $msg = "\n    - This package requires ".$job['packageName'].$this->constraintToText($job['constraint']).' but ';

 if (defined('HHVM_VERSION')) {
 return $msg . 'your HHVM version does not satisfy that requirement.';
 } elseif ($job['packageName'] === 'hhvm') {
 return $msg . 'you are running this with PHP and not HHVM.';
 }

 return $msg . 'your PHP version ('. $version .') does not satisfy that requirement.';
 }


 if (0 === stripos($job['packageName'], 'ext-')) {
 $ext = substr($job['packageName'], 4);
 $error = extension_loaded($ext) ? 'has the wrong version ('.(phpversion($ext) ?: '0').') installed' : 'is missing from your system';

 return "\n    - The requested PHP extension ".$job['packageName'].$this->constraintToText($job['constraint']).' '.$error.'.';
 }


 if (0 === stripos($job['packageName'], 'lib-')) {
 if (strtolower($job['packageName']) === 'lib-icu') {
 $error = extension_loaded('intl') ? 'has the wrong version installed, try upgrading the intl extension.' : 'is missing from your system, make sure the intl extension is loaded.';

 return "\n    - The requested linked library ".$job['packageName'].$this->constraintToText($job['constraint']).' '.$error;
 }

 return "\n    - The requested linked library ".$job['packageName'].$this->constraintToText($job['constraint']).' has the wrong version installed or is missing from your system, make sure to load the extension providing it.';
 }

 if (!preg_match('{^[A-Za-z0-9_./-]+$}', $job['packageName'])) {
 $illegalChars = preg_replace('{[A-Za-z0-9_./-]+}', '', $job['packageName']);

 return "\n    - The requested package ".$job['packageName'].' could not be found, it looks like its name is invalid, "'.$illegalChars.'" is not allowed in package names.';
 }

 if (!$this->pool->whatProvides($job['packageName'])) {
 return "\n    - The requested package ".$job['packageName'].' could not be found in any version, there may be a typo in the package name.';
 }

 return "\n    - The requested package ".$job['packageName'].$this->constraintToText($job['constraint']).' could not be found.';
 }
 }

 $messages = array();

 foreach ($reasons as $reason) {
 $rule = $reason['rule'];
 $job = $reason['job'];

 if ($job) {
 $messages[] = $this->jobToText($job);
 } elseif ($rule) {
 if ($rule instanceof Rule) {
 $messages[] = $rule->getPrettyString($this->pool, $installedMap);
 }
 }
 }

 return "\n    - ".implode("\n    - ", $messages);
 }







 protected function addReason($id, $reason)
 {
 if (!isset($this->reasonSeen[$id])) {
 $this->reasonSeen[$id] = true;
 $this->reasons[$this->section][] = $reason;
 }
 }

 public function nextSection()
 {
 $this->section++;
 }







 protected function jobToText($job)
 {
 switch ($job['cmd']) {
 case 'install':
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 if (!$packages) {
 return 'No package found to satisfy install request for '.$job['packageName'].$this->constraintToText($job['constraint']);
 }

 return 'Installation request for '.$job['packageName'].$this->constraintToText($job['constraint']).' -> satisfiable by '.$this->getPackageList($packages).'.';
 case 'update':
 return 'Update request for '.$job['packageName'].$this->constraintToText($job['constraint']).'.';
 case 'remove':
 return 'Removal request for '.$job['packageName'].$this->constraintToText($job['constraint']).'';
 }

 if (isset($job['constraint'])) {
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 } else {
 $packages = array();
 }

 return 'Job(cmd='.$job['cmd'].', target='.$job['packageName'].', packages=['.$this->getPackageList($packages).'])';
 }

 protected function getPackageList($packages)
 {
 $prepared = array();
 foreach ($packages as $package) {
 $prepared[$package->getName()]['name'] = $package->getPrettyName();
 $prepared[$package->getName()]['versions'][$package->getVersion()] = $package->getPrettyVersion();
 }
 foreach ($prepared as $name => $package) {
 $prepared[$name] = $package['name'].'['.implode(', ', $package['versions']).']';
 }

 return implode(', ', $prepared);
 }







 protected function constraintToText($constraint)
 {
 return ($constraint) ? ' '.$constraint->getPrettyString() : '';
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\LinkConstraint\LinkConstraintInterface;




 class Request
 {
 protected $jobs;

 public function __construct()
 {
 $this->jobs = array();
 }

 public function install($packageName, LinkConstraintInterface $constraint = null)
 {
 $this->addJob($packageName, 'install', $constraint);
 }

 public function update($packageName, LinkConstraintInterface $constraint = null)
 {
 $this->addJob($packageName, 'update', $constraint);
 }

 public function remove($packageName, LinkConstraintInterface $constraint = null)
 {
 $this->addJob($packageName, 'remove', $constraint);
 }






 public function fix($packageName, LinkConstraintInterface $constraint = null)
 {
 $this->addJob($packageName, 'install', $constraint, true);
 }

 protected function addJob($packageName, $cmd, LinkConstraintInterface $constraint = null, $fixed = false)
 {
 $packageName = strtolower($packageName);

 $this->jobs[] = array(
 'cmd' => $cmd,
 'packageName' => $packageName,
 'constraint' => $constraint,
 'fixed' => $fixed
 );
 }

 public function updateAll()
 {
 $this->jobs[] = array('cmd' => 'update-all');
 }

 public function getJobs()
 {
 return $this->jobs;
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class Rule
 {
 const RULE_INTERNAL_ALLOW_UPDATE = 1;
 const RULE_JOB_INSTALL = 2;
 const RULE_JOB_REMOVE = 3;
 const RULE_PACKAGE_CONFLICT = 6;
 const RULE_PACKAGE_REQUIRES = 7;
 const RULE_PACKAGE_OBSOLETES = 8;
 const RULE_INSTALLED_PACKAGE_OBSOLETES = 9;
 const RULE_PACKAGE_SAME_NAME = 10;
 const RULE_PACKAGE_IMPLICIT_OBSOLETES = 11;
 const RULE_LEARNED = 12;
 const RULE_PACKAGE_ALIAS = 13;

 const BITFIELD_TYPE = 0;
 const BITFIELD_REASON = 8;
 const BITFIELD_DISABLED = 16;





 public $literals;

 protected $bitfield;
 protected $reasonData;

 public function __construct(array $literals, $reason, $reasonData, $job = null)
 {

 sort($literals);

 $this->literals = $literals;
 $this->reasonData = $reasonData;

 if ($job) {
 $this->job = $job;
 }

 $this->bitfield = (0 << self::BITFIELD_DISABLED) |
 ($reason << self::BITFIELD_REASON) |
 (255 << self::BITFIELD_TYPE);
 }

 public function getHash()
 {
 $data = unpack('ihash', md5(implode(',', $this->literals), true));
 return $data['hash'];
 }

 public function getJob()
 {
 return isset($this->job) ? $this->job : null;
 }

 public function getReason()
 {
 return ($this->bitfield & (255 << self::BITFIELD_REASON)) >> self::BITFIELD_REASON;
 }

 public function getReasonData()
 {
 return $this->reasonData;
 }

 public function getRequiredPackage()
 {
 if ($this->getReason() === self::RULE_JOB_INSTALL) {
 return $this->reasonData;
 }

 if ($this->getReason() === self::RULE_PACKAGE_REQUIRES) {
 return $this->reasonData->getTarget();
 }
 }









 public function equals(Rule $rule)
 {
 if (count($this->literals) != count($rule->literals)) {
 return false;
 }

 for ($i = 0, $n = count($this->literals); $i < $n; $i++) {
 if ($this->literals[$i] !== $rule->literals[$i]) {
 return false;
 }
 }

 return true;
 }

 public function setType($type)
 {
 $this->bitfield = ($this->bitfield & ~(255 << self::BITFIELD_TYPE)) | ((255 & $type) << self::BITFIELD_TYPE);
 }

 public function getType()
 {
 return ($this->bitfield & (255 << self::BITFIELD_TYPE)) >> self::BITFIELD_TYPE;
 }

 public function disable()
 {
 $this->bitfield = ($this->bitfield & ~(255 << self::BITFIELD_DISABLED)) | (1 << self::BITFIELD_DISABLED);
 }

 public function enable()
 {
 $this->bitfield = $this->bitfield & ~(255 << self::BITFIELD_DISABLED);
 }

 public function isDisabled()
 {
 return (bool) (($this->bitfield & (255 << self::BITFIELD_DISABLED)) >> self::BITFIELD_DISABLED);
 }

 public function isEnabled()
 {
 return !(($this->bitfield & (255 << self::BITFIELD_DISABLED)) >> self::BITFIELD_DISABLED);
 }




 public function getLiterals()
 {
 return $this->literals;
 }

 public function isAssertion()
 {
 return 1 === count($this->literals);
 }

 public function getPrettyString(Pool $pool, array $installedMap = array())
 {
 $ruleText = '';
 foreach ($this->literals as $i => $literal) {
 if ($i != 0) {
 $ruleText .= '|';
 }
 $ruleText .= $pool->literalToPrettyString($literal, $installedMap);
 }

 switch ($this->getReason()) {
 case self::RULE_INTERNAL_ALLOW_UPDATE:
 return $ruleText;

 case self::RULE_JOB_INSTALL:
 return "Install command rule ($ruleText)";

 case self::RULE_JOB_REMOVE:
 return "Remove command rule ($ruleText)";

 case self::RULE_PACKAGE_CONFLICT:
 $package1 = $pool->literalToPackage($this->literals[0]);
 $package2 = $pool->literalToPackage($this->literals[1]);

 return $package1->getPrettyString().' conflicts with '.$this->formatPackagesUnique($pool, array($package2)).'.';

 case self::RULE_PACKAGE_REQUIRES:
 $literals = $this->literals;
 $sourceLiteral = array_shift($literals);
 $sourcePackage = $pool->literalToPackage($sourceLiteral);

 $requires = array();
 foreach ($literals as $literal) {
 $requires[] = $pool->literalToPackage($literal);
 }

 $text = $this->reasonData->getPrettyString($sourcePackage);
 if ($requires) {
 $text .= ' -> satisfiable by ' . $this->formatPackagesUnique($pool, $requires) . '.';
 } else {
 $targetName = $this->reasonData->getTarget();

 if ($targetName === 'php' || $targetName === 'php-64bit' || $targetName === 'hhvm') {

 if (defined('HHVM_VERSION')) {
 $text .= ' -> your HHVM version does not satisfy that requirement.';
 } elseif ($targetName === 'hhvm') {
 $text .= ' -> you are running this with PHP and not HHVM.';
 } else {
 $text .= ' -> your PHP version ('. phpversion() .') or "config.platform.php" value does not satisfy that requirement.';
 }
 } elseif (0 === strpos($targetName, 'ext-')) {

 $ext = substr($targetName, 4);
 $error = extension_loaded($ext) ? 'has the wrong version ('.(phpversion($ext) ?: '0').') installed' : 'is missing from your system';

 $text .= ' -> the requested PHP extension '.$ext.' '.$error.'.';
 } elseif (0 === strpos($targetName, 'lib-')) {

 $lib = substr($targetName, 4);

 $text .= ' -> the requested linked library '.$lib.' has the wrong version installed or is missing from your system, make sure to have the extension providing it.';
 } else {
 $text .= ' -> no matching package found.';
 }
 }

 return $text;

 case self::RULE_PACKAGE_OBSOLETES:
 return $ruleText;
 case self::RULE_INSTALLED_PACKAGE_OBSOLETES:
 return $ruleText;
 case self::RULE_PACKAGE_SAME_NAME:
 return 'Can only install one of: ' . $this->formatPackagesUnique($pool, $this->literals) . '.';
 case self::RULE_PACKAGE_IMPLICIT_OBSOLETES:
 return $ruleText;
 case self::RULE_LEARNED:
 return 'Conclusion: '.$ruleText;
 case self::RULE_PACKAGE_ALIAS:
 return $ruleText;
 default:
 return '('.$ruleText.')';
 }
 }

 protected function formatPackagesUnique($pool, array $packages)
 {
 $prepared = array();
 foreach ($packages as $package) {
 if (!is_object($package)) {
 $package = $pool->literalToPackage($package);
 }
 $prepared[$package->getName()]['name'] = $package->getPrettyName();
 $prepared[$package->getName()]['versions'][$package->getVersion()] = $package->getPrettyVersion();
 }
 foreach ($prepared as $name => $package) {
 $prepared[$name] = $package['name'].'['.implode(', ', $package['versions']).']';
 }

 return implode(', ', $prepared);
 }






 public function __toString()
 {
 $result = ($this->isDisabled()) ? 'disabled(' : '(';

 foreach ($this->literals as $i => $literal) {
 if ($i != 0) {
 $result .= '|';
 }
 $result .= $literal;
 }

 $result .= ')';

 return $result;
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class RuleSet implements \IteratorAggregate, \Countable
 {

 const TYPE_PACKAGE = 0;
 const TYPE_JOB = 1;
 const TYPE_LEARNED = 4;






 public $ruleById;

 protected static $types = array(
 255 => 'UNKNOWN',
 self::TYPE_PACKAGE => 'PACKAGE',
 self::TYPE_JOB => 'JOB',
 self::TYPE_LEARNED => 'LEARNED',
 );

 protected $rules;
 protected $nextRuleId;

 protected $rulesByHash;

 public function __construct()
 {
 $this->nextRuleId = 0;

 foreach ($this->getTypes() as $type) {
 $this->rules[$type] = array();
 }

 $this->rulesByHash = array();
 }

 public function add(Rule $rule, $type)
 {
 if (!isset(self::$types[$type])) {
 throw new \OutOfBoundsException('Unknown rule type: ' . $type);
 }

 if (!isset($this->rules[$type])) {
 $this->rules[$type] = array();
 }

 $this->rules[$type][] = $rule;
 $this->ruleById[$this->nextRuleId] = $rule;
 $rule->setType($type);

 $this->nextRuleId++;

 $hash = $rule->getHash();
 if (!isset($this->rulesByHash[$hash])) {
 $this->rulesByHash[$hash] = array($rule);
 } else {
 $this->rulesByHash[$hash][] = $rule;
 }
 }

 public function count()
 {
 return $this->nextRuleId;
 }

 public function ruleById($id)
 {
 return $this->ruleById[$id];
 }

 public function getRules()
 {
 return $this->rules;
 }

 public function getIterator()
 {
 return new RuleSetIterator($this->getRules());
 }

 public function getIteratorFor($types)
 {
 if (!is_array($types)) {
 $types = array($types);
 }

 $allRules = $this->getRules();
 $rules = array();

 foreach ($types as $type) {
 $rules[$type] = $allRules[$type];
 }

 return new RuleSetIterator($rules);
 }

 public function getIteratorWithout($types)
 {
 if (!is_array($types)) {
 $types = array($types);
 }

 $rules = $this->getRules();

 foreach ($types as $type) {
 unset($rules[$type]);
 }

 return new RuleSetIterator($rules);
 }

 public function getTypes()
 {
 $types = self::$types;
 unset($types[255]);

 return array_keys($types);
 }

 public function containsEqual($rule)
 {
 if (isset($this->rulesByHash[$rule->getHash()])) {
 $potentialDuplicates = $this->rulesByHash[$rule->getHash()];
 foreach ($potentialDuplicates as $potentialDuplicate) {
 if ($rule->equals($potentialDuplicate)) {
 return true;
 }
 }
 }

 return false;
 }

 public function getPrettyString(Pool $pool = null)
 {
 $string = "\n";
 foreach ($this->rules as $type => $rules) {
 $string .= str_pad(self::$types[$type], 8, ' ') . ": ";
 foreach ($rules as $rule) {
 $string .= ($pool ? $rule->getPrettyString($pool) : $rule)."\n";
 }
 $string .= "\n\n";
 }

 return $string;
 }

 public function __toString()
 {
 return $this->getPrettyString(null);
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\PackageInterface;
 use Composer\Package\AliasPackage;
 use Composer\Repository\PlatformRepository;




 class RuleSetGenerator
 {
 protected $policy;
 protected $pool;
 protected $rules;
 protected $jobs;
 protected $installedMap;
 protected $whitelistedMap;
 protected $addedMap;

 public function __construct(PolicyInterface $policy, Pool $pool)
 {
 $this->policy = $policy;
 $this->pool = $pool;
 }















 protected function createRequireRule(PackageInterface $package, array $providers, $reason, $reasonData = null)
 {
 $literals = array(-$package->id);

 foreach ($providers as $provider) {

 if ($provider === $package) {
 return null;
 }
 $literals[] = $provider->id;
 }

 return new Rule($literals, $reason, $reasonData);
 }













 protected function createInstallOneOfRule(array $packages, $reason, $job)
 {
 $literals = array();
 foreach ($packages as $package) {
 $literals[] = $package->id;
 }

 return new Rule($literals, $reason, $job['packageName'], $job);
 }












 protected function createRemoveRule(PackageInterface $package, $reason, $job)
 {
 return new Rule(array(-$package->id), $reason, $job['packageName'], $job);
 }















 protected function createConflictRule(PackageInterface $issuer, PackageInterface $provider, $reason, $reasonData = null)
 {

 if ($issuer === $provider) {
 return null;
 }

 return new Rule(array(-$issuer->id, -$provider->id), $reason, $reasonData);
 }










 private function addRule($type, Rule $newRule = null)
 {
 if (!$newRule || $this->rules->containsEqual($newRule)) {
 return;
 }

 $this->rules->add($newRule, $type);
 }

 protected function whitelistFromPackage(PackageInterface $package)
 {
 $workQueue = new \SplQueue;
 $workQueue->enqueue($package);

 while (!$workQueue->isEmpty()) {
 $package = $workQueue->dequeue();
 if (isset($this->whitelistedMap[$package->id])) {
 continue;
 }

 $this->whitelistedMap[$package->id] = true;

 foreach ($package->getRequires() as $link) {
 $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint(), true);

 foreach ($possibleRequires as $require) {
 $workQueue->enqueue($require);
 }
 }

 $obsoleteProviders = $this->pool->whatProvides($package->getName(), null, true);

 foreach ($obsoleteProviders as $provider) {
 if ($provider === $package) {
 continue;
 }

 if (($package instanceof AliasPackage) && $package->getAliasOf() === $provider) {
 $workQueue->enqueue($provider);
 }
 }
 }
 }

 protected function addRulesForPackage(PackageInterface $package, $ignorePlatformReqs)
 {
 $workQueue = new \SplQueue;
 $workQueue->enqueue($package);

 while (!$workQueue->isEmpty()) {
 $package = $workQueue->dequeue();
 if (isset($this->addedMap[$package->id])) {
 continue;
 }

 $this->addedMap[$package->id] = true;

 foreach ($package->getRequires() as $link) {
 if ($ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $link->getTarget())) {
 continue;
 }

 $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());

 $this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createRequireRule($package, $possibleRequires, Rule::RULE_PACKAGE_REQUIRES, $link));

 foreach ($possibleRequires as $require) {
 $workQueue->enqueue($require);
 }
 }

 foreach ($package->getConflicts() as $link) {
 $possibleConflicts = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());

 foreach ($possibleConflicts as $conflict) {
 $this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $conflict, Rule::RULE_PACKAGE_CONFLICT, $link));
 }
 }


 $isInstalled = (isset($this->installedMap[$package->id]));

 foreach ($package->getReplaces() as $link) {
 $obsoleteProviders = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());

 foreach ($obsoleteProviders as $provider) {
 if ($provider === $package) {
 continue;
 }

 if (!$this->obsoleteImpossibleForAlias($package, $provider)) {
 $reason = ($isInstalled) ? Rule::RULE_INSTALLED_PACKAGE_OBSOLETES : Rule::RULE_PACKAGE_OBSOLETES;
 $this->addRule(RuleSet::TYPE_PACKAGE, $this->createConflictRule($package, $provider, $reason, $link));
 }
 }
 }

 $obsoleteProviders = $this->pool->whatProvides($package->getName(), null);

 foreach ($obsoleteProviders as $provider) {
 if ($provider === $package) {
 continue;
 }

 if (($package instanceof AliasPackage) && $package->getAliasOf() === $provider) {
 $this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createRequireRule($package, array($provider), Rule::RULE_PACKAGE_ALIAS, $package));
 } elseif (!$this->obsoleteImpossibleForAlias($package, $provider)) {
 $reason = ($package->getName() == $provider->getName()) ? Rule::RULE_PACKAGE_SAME_NAME : Rule::RULE_PACKAGE_IMPLICIT_OBSOLETES;
 $this->addRule(RuleSet::TYPE_PACKAGE, $rule = $this->createConflictRule($package, $provider, $reason, $package));
 }
 }
 }
 }

 protected function obsoleteImpossibleForAlias($package, $provider)
 {
 $packageIsAlias = $package instanceof AliasPackage;
 $providerIsAlias = $provider instanceof AliasPackage;

 $impossible = (
 ($packageIsAlias && $package->getAliasOf() === $provider) ||
 ($providerIsAlias && $provider->getAliasOf() === $package) ||
 ($packageIsAlias && $providerIsAlias && $provider->getAliasOf() === $package->getAliasOf())
 );

 return $impossible;
 }

 protected function whitelistFromJobs()
 {
 foreach ($this->jobs as $job) {
 switch ($job['cmd']) {
 case 'install':
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint'], true);
 foreach ($packages as $package) {
 $this->whitelistFromPackage($package);
 }
 break;
 }
 }
 }

 protected function addRulesForJobs($ignorePlatformReqs)
 {
 foreach ($this->jobs as $job) {
 switch ($job['cmd']) {
 case 'install':
 if (!$job['fixed'] && $ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $job['packageName'])) {
 continue;
 }

 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 if ($packages) {
 foreach ($packages as $package) {
 if (!isset($this->installedMap[$package->id])) {
 $this->addRulesForPackage($package, $ignorePlatformReqs);
 }
 }

 $rule = $this->createInstallOneOfRule($packages, Rule::RULE_JOB_INSTALL, $job);
 $this->addRule(RuleSet::TYPE_JOB, $rule);
 }
 break;
 case 'remove':

 
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 foreach ($packages as $package) {
 $rule = $this->createRemoveRule($package, Rule::RULE_JOB_REMOVE, $job);
 $this->addRule(RuleSet::TYPE_JOB, $rule);
 }
 break;
 }
 }
 }

 public function getRulesFor($jobs, $installedMap, $ignorePlatformReqs = false)
 {
 $this->jobs = $jobs;
 $this->rules = new RuleSet;
 $this->installedMap = $installedMap;

 $this->whitelistedMap = array();
 foreach ($this->installedMap as $package) {
 $this->whitelistFromPackage($package);
 }
 $this->whitelistFromJobs();

 $this->pool->setWhitelist($this->whitelistedMap);

 $this->addedMap = array();
 foreach ($this->installedMap as $package) {
 $this->addRulesForPackage($package, $ignorePlatformReqs);
 }

 $this->addRulesForJobs($ignorePlatformReqs);

 return $this->rules;
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class RuleSetIterator implements \Iterator
 {
 protected $rules;
 protected $types;

 protected $currentOffset;
 protected $currentType;
 protected $currentTypeOffset;

 public function __construct(array $rules)
 {
 $this->rules = $rules;
 $this->types = array_keys($rules);
 sort($this->types);

 $this->rewind();
 }

 public function current()
 {
 return $this->rules[$this->currentType][$this->currentOffset];
 }

 public function key()
 {
 return $this->currentType;
 }

 public function next()
 {
 $this->currentOffset++;

 if (!isset($this->rules[$this->currentType])) {
 return;
 }

 if ($this->currentOffset >= sizeof($this->rules[$this->currentType])) {
 $this->currentOffset = 0;

 do {
 $this->currentTypeOffset++;

 if (!isset($this->types[$this->currentTypeOffset])) {
 $this->currentType = -1;
 break;
 }

 $this->currentType = $this->types[$this->currentTypeOffset];
 } while (isset($this->types[$this->currentTypeOffset]) && !sizeof($this->rules[$this->currentType]));
 }
 }

 public function rewind()
 {
 $this->currentOffset = 0;

 $this->currentTypeOffset = -1;
 $this->currentType = -1;

 do {
 $this->currentTypeOffset++;

 if (!isset($this->types[$this->currentTypeOffset])) {
 $this->currentType = -1;
 break;
 }

 $this->currentType = $this->types[$this->currentTypeOffset];
 } while (isset($this->types[$this->currentTypeOffset]) && !sizeof($this->rules[$this->currentType]));
 }

 public function valid()
 {
 return isset($this->rules[$this->currentType])
 && isset($this->rules[$this->currentType][$this->currentOffset]);
 }
 }
 <?php











 namespace Composer\DependencyResolver;









 class RuleWatchChain extends \SplDoublyLinkedList
 {
 protected $offset = 0;






 public function seek($offset)
 {
 $this->rewind();
 for ($i = 0; $i < $offset; $i++, $this->next());
 }









 public function remove()
 {
 $offset = $this->key();
 $this->offsetUnset($offset);
 $this->seek($offset);
 }
 }
 <?php











 namespace Composer\DependencyResolver;











 class RuleWatchGraph
 {
 protected $watchChains = array();













 public function insert(RuleWatchNode $node)
 {
 if ($node->getRule()->isAssertion()) {
 return;
 }

 foreach (array($node->watch1, $node->watch2) as $literal) {
 if (!isset($this->watchChains[$literal])) {
 $this->watchChains[$literal] = new RuleWatchChain;
 }

 $this->watchChains[$literal]->unshift($node);
 }
 }
























 public function propagateLiteral($decidedLiteral, $level, $decisions)
 {

 
 
 $literal = -$decidedLiteral;

 if (!isset($this->watchChains[$literal])) {
 return null;
 }

 $chain = $this->watchChains[$literal];

 $chain->rewind();
 while ($chain->valid()) {
 $node = $chain->current();
 $otherWatch = $node->getOtherWatch($literal);

 if (!$node->getRule()->isDisabled() && !$decisions->satisfy($otherWatch)) {
 $ruleLiterals = $node->getRule()->literals;

 $alternativeLiterals = array_filter($ruleLiterals, function ($ruleLiteral) use ($literal, $otherWatch, $decisions) {
 return $literal !== $ruleLiteral &&
 $otherWatch !== $ruleLiteral &&
 !$decisions->conflict($ruleLiteral);
 });

 if ($alternativeLiterals) {
 reset($alternativeLiterals);
 $this->moveWatch($literal, current($alternativeLiterals), $node);
 continue;
 }

 if ($decisions->conflict($otherWatch)) {
 return $node->getRule();
 }

 $decisions->decide($otherWatch, $level, $node->getRule());
 }

 $chain->next();
 }

 return null;
 }










 protected function moveWatch($fromLiteral, $toLiteral, $node)
 {
 if (!isset($this->watchChains[$toLiteral])) {
 $this->watchChains[$toLiteral] = new RuleWatchChain;
 }

 $node->moveWatch($fromLiteral, $toLiteral);
 $this->watchChains[$fromLiteral]->remove();
 $this->watchChains[$toLiteral]->unshift($node);
 }
 }
 <?php











 namespace Composer\DependencyResolver;








 class RuleWatchNode
 {
 public $watch1;
 public $watch2;

 protected $rule;






 public function __construct($rule)
 {
 $this->rule = $rule;

 $literals = $rule->literals;

 $this->watch1 = count($literals) > 0 ? $literals[0] : 0;
 $this->watch2 = count($literals) > 1 ? $literals[1] : 0;
 }









 public function watch2OnHighest(Decisions $decisions)
 {
 $literals = $this->rule->literals;


 if (count($literals) < 3) {
 return;
 }

 $watchLevel = 0;

 foreach ($literals as $literal) {
 $level = $decisions->decisionLevel($literal);

 if ($level > $watchLevel) {
 $this->watch2 = $literal;
 $watchLevel = $level;
 }
 }
 }






 public function getRule()
 {
 return $this->rule;
 }







 public function getOtherWatch($literal)
 {
 if ($this->watch1 == $literal) {
 return $this->watch2;
 } else {
 return $this->watch1;
 }
 }







 public function moveWatch($from, $to)
 {
 if ($this->watch1 == $from) {
 $this->watch1 = $to;
 } else {
 $this->watch2 = $to;
 }
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\PlatformRepository;




 class Solver
 {
 const BRANCH_LITERALS = 0;
 const BRANCH_LEVEL = 1;

 protected $policy;
 protected $pool;
 protected $installed;
 protected $rules;
 protected $ruleSetGenerator;
 protected $updateAll;

 protected $addedMap = array();
 protected $updateMap = array();
 protected $watchGraph;
 protected $decisions;
 protected $installedMap;

 protected $propagateIndex;
 protected $branches = array();
 protected $problems = array();
 protected $learnedPool = array();
 protected $learnedWhy = array();

 public function __construct(PolicyInterface $policy, Pool $pool, RepositoryInterface $installed)
 {
 $this->policy = $policy;
 $this->pool = $pool;
 $this->installed = $installed;
 $this->ruleSetGenerator = new RuleSetGenerator($policy, $pool);
 }

 public function getRuleSetSize()
 {
 return count($this->rules);
 }


 private function makeAssertionRuleDecisions()
 {
 $decisionStart = count($this->decisions) - 1;

 $rulesCount = count($this->rules);
 for ($ruleIndex = 0; $ruleIndex < $rulesCount; $ruleIndex++) {
 $rule = $this->rules->ruleById[$ruleIndex];

 if (!$rule->isAssertion() || $rule->isDisabled()) {
 continue;
 }

 $literals = $rule->literals;
 $literal = $literals[0];

 if (!$this->decisions->decided(abs($literal))) {
 $this->decisions->decide($literal, 1, $rule);
 continue;
 }

 if ($this->decisions->satisfy($literal)) {
 continue;
 }


 if (RuleSet::TYPE_LEARNED === $rule->getType()) {
 $rule->disable();
 continue;
 }

 $conflict = $this->decisions->decisionRule($literal);

 if ($conflict && RuleSet::TYPE_PACKAGE === $conflict->getType()) {
 $problem = new Problem($this->pool);

 $problem->addRule($rule);
 $problem->addRule($conflict);
 $this->disableProblem($rule);
 $this->problems[] = $problem;
 continue;
 }


 $problem = new Problem($this->pool);
 $problem->addRule($rule);
 $problem->addRule($conflict);


 
 foreach ($this->rules->getIteratorFor(RuleSet::TYPE_JOB) as $assertRule) {
 if ($assertRule->isDisabled() || !$assertRule->isAssertion()) {
 continue;
 }

 $assertRuleLiterals = $assertRule->literals;
 $assertRuleLiteral = $assertRuleLiterals[0];

 if (abs($literal) !== abs($assertRuleLiteral)) {
 continue;
 }

 $problem->addRule($assertRule);
 $this->disableProblem($assertRule);
 }
 $this->problems[] = $problem;

 $this->decisions->resetToOffset($decisionStart);
 $ruleIndex = -1;
 }
 }

 protected function setupInstalledMap()
 {
 $this->installedMap = array();
 foreach ($this->installed->getPackages() as $package) {
 $this->installedMap[$package->id] = $package;
 }
 }

 protected function checkForRootRequireProblems($ignorePlatformReqs)
 {
 foreach ($this->jobs as $job) {
 switch ($job['cmd']) {
 case 'update':
 $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
 foreach ($packages as $package) {
 if (isset($this->installedMap[$package->id])) {
 $this->updateMap[$package->id] = true;
 }
 }
 break;

 case 'update-all':
 foreach ($this->installedMap as $package) {
 $this->updateMap[$package->id] = true;
 }
 break;

 case 'install':
 if ($ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $job['packageName'])) {
 break;
 }

 if (!$this->pool->whatProvides($job['packageName'], $job['constraint'])) {
 $problem = new Problem($this->pool);
 $problem->addRule(new Rule(array(), null, null, $job));
 $this->problems[] = $problem;
 }
 break;
 }
 }
 }

 public function solve(Request $request, $ignorePlatformReqs = false)
 {
 $this->jobs = $request->getJobs();

 $this->setupInstalledMap();
 $this->rules = $this->ruleSetGenerator->getRulesFor($this->jobs, $this->installedMap, $ignorePlatformReqs);
 $this->checkForRootRequireProblems($ignorePlatformReqs);
 $this->decisions = new Decisions($this->pool);
 $this->watchGraph = new RuleWatchGraph;

 foreach ($this->rules as $rule) {
 $this->watchGraph->insert(new RuleWatchNode($rule));
 }


 $this->makeAssertionRuleDecisions();

 $this->runSat(true);


 foreach ($this->installedMap as $packageId => $void) {
 if ($this->decisions->undecided($packageId)) {
 $this->decisions->decide(-$packageId, 1, null);
 }
 }

 if ($this->problems) {
 throw new SolverProblemsException($this->problems, $this->installedMap);
 }

 $transaction = new Transaction($this->policy, $this->pool, $this->installedMap, $this->decisions);

 return $transaction->getOperations();
 }

 protected function literalFromId($id)
 {
 $package = $this->pool->packageById(abs($id));

 return new Literal($package, $id > 0);
 }










 protected function propagate($level)
 {
 while ($this->decisions->validOffset($this->propagateIndex)) {
 $decision = $this->decisions->atOffset($this->propagateIndex);

 $conflict = $this->watchGraph->propagateLiteral(
 $decision[Decisions::DECISION_LITERAL],
 $level,
 $this->decisions
 );

 $this->propagateIndex++;

 if ($conflict) {
 return $conflict;
 }
 }

 return null;
 }




 private function revert($level)
 {
 while (!$this->decisions->isEmpty()) {
 $literal = $this->decisions->lastLiteral();

 if ($this->decisions->undecided($literal)) {
 break;
 }

 $decisionLevel = $this->decisions->decisionLevel($literal);

 if ($decisionLevel <= $level) {
 break;
 }

 $this->decisions->revertLast();
 $this->propagateIndex = count($this->decisions);
 }

 while (!empty($this->branches) && $this->branches[count($this->branches) - 1][self::BRANCH_LEVEL] >= $level) {
 array_pop($this->branches);
 }
 }
















 private function setPropagateLearn($level, $literal, $disableRules, Rule $rule)
 {
 $level++;

 $this->decisions->decide($literal, $level, $rule);

 while (true) {
 $rule = $this->propagate($level);

 if (!$rule) {
 break;
 }

 if ($level == 1) {
 return $this->analyzeUnsolvable($rule, $disableRules);
 }


 list($learnLiteral, $newLevel, $newRule, $why) = $this->analyze($level, $rule);

 if ($newLevel <= 0 || $newLevel >= $level) {
 throw new SolverBugException(
 "Trying to revert to invalid level ".(int) $newLevel." from level ".(int) $level."."
 );
 } elseif (!$newRule) {
 throw new SolverBugException(
 "No rule was learned from analyzing $rule at level $level."
 );
 }

 $level = $newLevel;

 $this->revert($level);

 $this->rules->add($newRule, RuleSet::TYPE_LEARNED);

 $this->learnedWhy[spl_object_hash($newRule)] = $why;

 $ruleNode = new RuleWatchNode($newRule);
 $ruleNode->watch2OnHighest($this->decisions);
 $this->watchGraph->insert($ruleNode);

 $this->decisions->decide($learnLiteral, $level, $newRule);
 }

 return $level;
 }

 private function selectAndInstall($level, array $decisionQueue, $disableRules, Rule $rule)
 {

 $literals = $this->policy->selectPreferredPackages($this->pool, $this->installedMap, $decisionQueue, $rule->getRequiredPackage());

 $selectedLiteral = array_shift($literals);


 if (count($literals)) {
 $this->branches[] = array($literals, $level);
 }

 return $this->setPropagateLearn($level, $selectedLiteral, $disableRules, $rule);
 }

 protected function analyze($level, $rule)
 {
 $analyzedRule = $rule;
 $ruleLevel = 1;
 $num = 0;
 $l1num = 0;
 $seen = array();
 $learnedLiterals = array(null);

 $decisionId = count($this->decisions);

 $this->learnedPool[] = array();

 while (true) {
 $this->learnedPool[count($this->learnedPool) - 1][] = $rule;

 foreach ($rule->literals as $literal) {

 if ($this->decisions->satisfy($literal)) {
 continue;
 }

 if (isset($seen[abs($literal)])) {
 continue;
 }
 $seen[abs($literal)] = true;

 $l = $this->decisions->decisionLevel($literal);

 if (1 === $l) {
 $l1num++;
 } elseif ($level === $l) {
 $num++;
 } else {

 $learnedLiterals[] = $literal;

 if ($l > $ruleLevel) {
 $ruleLevel = $l;
 }
 }
 }

 $l1retry = true;
 while ($l1retry) {
 $l1retry = false;

 if (!$num && !--$l1num) {

 break 2;
 }

 while (true) {
 if ($decisionId <= 0) {
 throw new SolverBugException(
 "Reached invalid decision id $decisionId while looking through $rule for a literal present in the analyzed rule $analyzedRule."
 );
 }

 $decisionId--;

 $decision = $this->decisions->atOffset($decisionId);
 $literal = $decision[Decisions::DECISION_LITERAL];

 if (isset($seen[abs($literal)])) {
 break;
 }
 }

 unset($seen[abs($literal)]);

 if ($num && 0 === --$num) {
 $learnedLiterals[0] = -abs($literal);

 if (!$l1num) {
 break 2;
 }

 foreach ($learnedLiterals as $i => $learnedLiteral) {
 if ($i !== 0) {
 unset($seen[abs($learnedLiteral)]);
 }
 }

 $l1num++;
 $l1retry = true;
 }
 }

 $decision = $this->decisions->atOffset($decisionId);
 $rule = $decision[Decisions::DECISION_REASON];
 }

 $why = count($this->learnedPool) - 1;

 if (!$learnedLiterals[0]) {
 throw new SolverBugException(
 "Did not find a learnable literal in analyzed rule $analyzedRule."
 );
 }

 $newRule = new Rule($learnedLiterals, Rule::RULE_LEARNED, $why);

 return array($learnedLiterals[0], $ruleLevel, $newRule, $why);
 }

 private function analyzeUnsolvableRule($problem, $conflictRule)
 {
 $why = spl_object_hash($conflictRule);

 if ($conflictRule->getType() == RuleSet::TYPE_LEARNED) {
 $learnedWhy = $this->learnedWhy[$why];
 $problemRules = $this->learnedPool[$learnedWhy];

 foreach ($problemRules as $problemRule) {
 $this->analyzeUnsolvableRule($problem, $problemRule);
 }

 return;
 }

 if ($conflictRule->getType() == RuleSet::TYPE_PACKAGE) {

 return;
 }

 $problem->nextSection();
 $problem->addRule($conflictRule);
 }

 private function analyzeUnsolvable($conflictRule, $disableRules)
 {
 $problem = new Problem($this->pool);
 $problem->addRule($conflictRule);

 $this->analyzeUnsolvableRule($problem, $conflictRule);

 $this->problems[] = $problem;

 $seen = array();
 $literals = $conflictRule->literals;

 foreach ($literals as $literal) {

 if ($this->decisions->satisfy($literal)) {
 continue;
 }
 $seen[abs($literal)] = true;
 }

 foreach ($this->decisions as $decision) {
 $literal = $decision[Decisions::DECISION_LITERAL];


 if (!isset($seen[abs($literal)])) {
 continue;
 }

 $why = $decision[Decisions::DECISION_REASON];

 $problem->addRule($why);
 $this->analyzeUnsolvableRule($problem, $why);

 $literals = $why->literals;

 foreach ($literals as $literal) {

 if ($this->decisions->satisfy($literal)) {
 continue;
 }
 $seen[abs($literal)] = true;
 }
 }

 if ($disableRules) {
 foreach ($this->problems[count($this->problems) - 1] as $reason) {
 $this->disableProblem($reason['rule']);
 }

 $this->resetSolver();

 return 1;
 }

 return 0;
 }

 private function disableProblem($why)
 {
 $job = $why->getJob();

 if (!$job) {
 $why->disable();

 return;
 }


 foreach ($this->rules as $rule) {
 if ($job === $rule->getJob()) {
 $rule->disable();
 }
 }
 }

 private function resetSolver()
 {
 $this->decisions->reset();

 $this->propagateIndex = 0;
 $this->branches = array();

 $this->enableDisableLearnedRules();
 $this->makeAssertionRuleDecisions();
 }








 private function enableDisableLearnedRules()
 {
 foreach ($this->rules->getIteratorFor(RuleSet::TYPE_LEARNED) as $rule) {
 $why = $this->learnedWhy[spl_object_hash($rule)];
 $problemRules = $this->learnedPool[$why];

 $foundDisabled = false;
 foreach ($problemRules as $problemRule) {
 if ($problemRule->isDisabled()) {
 $foundDisabled = true;
 break;
 }
 }

 if ($foundDisabled && $rule->isEnabled()) {
 $rule->disable();
 } elseif (!$foundDisabled && $rule->isDisabled()) {
 $rule->enable();
 }
 }
 }

 private function runSat($disableRules = true)
 {
 $this->propagateIndex = 0;


 
 
 
 
 
 
 
 

 $decisionQueue = array();
 $decisionSupplementQueue = array();
 $disableRules = array();

 $level = 1;
 $systemLevel = $level + 1;
 $installedPos = 0;

 while (true) {
 if (1 === $level) {
 $conflictRule = $this->propagate($level);
 if (null !== $conflictRule) {
 if ($this->analyzeUnsolvable($conflictRule, $disableRules)) {
 continue;
 }

 return;
 }
 }


 if ($level < $systemLevel) {
 $iterator = $this->rules->getIteratorFor(RuleSet::TYPE_JOB);
 foreach ($iterator as $rule) {
 if ($rule->isEnabled()) {
 $decisionQueue = array();
 $noneSatisfied = true;

 foreach ($rule->literals as $literal) {
 if ($this->decisions->satisfy($literal)) {
 $noneSatisfied = false;
 break;
 }
 if ($literal > 0 && $this->decisions->undecided($literal)) {
 $decisionQueue[] = $literal;
 }
 }

 if ($noneSatisfied && count($decisionQueue)) {

 
 if (count($this->installed) != count($this->updateMap)) {
 $prunedQueue = array();
 foreach ($decisionQueue as $literal) {
 if (isset($this->installedMap[abs($literal)])) {
 $prunedQueue[] = $literal;
 if (isset($this->updateMap[abs($literal)])) {
 $prunedQueue = $decisionQueue;
 break;
 }
 }
 }
 $decisionQueue = $prunedQueue;
 }
 }

 if ($noneSatisfied && count($decisionQueue)) {
 $oLevel = $level;
 $level = $this->selectAndInstall($level, $decisionQueue, $disableRules, $rule);

 if (0 === $level) {
 return;
 }
 if ($level <= $oLevel) {
 break;
 }
 }
 }
 }

 $systemLevel = $level + 1;


 $iterator->next();
 if ($iterator->valid()) {
 continue;
 }
 }

 if ($level < $systemLevel) {
 $systemLevel = $level;
 }

 for ($i = 0, $n = 0; $n < count($this->rules); $i++, $n++) {
 if ($i == count($this->rules)) {
 $i = 0;
 }

 $rule = $this->rules->ruleById[$i];
 $literals = $rule->literals;

 if ($rule->isDisabled()) {
 continue;
 }

 $decisionQueue = array();


 
 
 
 
 
 foreach ($literals as $literal) {
 if ($literal <= 0) {
 if (!$this->decisions->decidedInstall(abs($literal))) {
 continue 2; 
 }
 } else {
 if ($this->decisions->decidedInstall(abs($literal))) {
 continue 2; 
 }
 if ($this->decisions->undecided(abs($literal))) {
 $decisionQueue[] = $literal;
 }
 }
 }


 if (count($decisionQueue) < 2) {
 continue;
 }

 $oLevel = $level;
 $level = $this->selectAndInstall($level, $decisionQueue, $disableRules, $rule);

 if (0 === $level) {
 return;
 }


 $n = -1;
 }

 if ($level < $systemLevel) {
 continue;
 }


 if (count($this->branches)) {
 $lastLiteral = null;
 $lastLevel = null;
 $lastBranchIndex = 0;
 $lastBranchOffset = 0;
 $l = 0;

 for ($i = count($this->branches) - 1; $i >= 0; $i--) {
 list($literals, $l) = $this->branches[$i];

 foreach ($literals as $offset => $literal) {
 if ($literal && $literal > 0 && $this->decisions->decisionLevel($literal) > $l + 1) {
 $lastLiteral = $literal;
 $lastBranchIndex = $i;
 $lastBranchOffset = $offset;
 $lastLevel = $l;
 }
 }
 }

 if ($lastLiteral) {
 unset($this->branches[$lastBranchIndex][self::BRANCH_LITERALS][$lastBranchOffset]);

 $level = $lastLevel;
 $this->revert($level);

 $why = $this->decisions->lastReason();

 $oLevel = $level;
 $level = $this->setPropagateLearn($level, $lastLiteral, $disableRules, $why);

 if ($level == 0) {
 return;
 }

 continue;
 }
 }

 break;
 }
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class SolverBugException extends \RuntimeException
 {
 public function __construct($message)
 {
 parent::__construct(
 $message."\nThis exception was most likely caused by a bug in Composer.\n".
 "Please report the command you ran, the exact error you received, and your composer.json on https://github.com/composer/composer/issues - thank you!\n");
 }
 }
 <?php











 namespace Composer\DependencyResolver;




 class SolverProblemsException extends \RuntimeException
 {
 protected $problems;
 protected $installedMap;

 public function __construct(array $problems, array $installedMap)
 {
 $this->problems = $problems;
 $this->installedMap = $installedMap;

 parent::__construct($this->createMessage(), 2);
 }

 protected function createMessage()
 {
 $text = "\n";
 foreach ($this->problems as $i => $problem) {
 $text .= "  Problem ".($i + 1).$problem->getPrettyString($this->installedMap)."\n";
 }

 if (strpos($text, 'could not be found') || strpos($text, 'no matching package found')) {
 $text .= "\nPotential causes:\n - A typo in the package name\n - The package is not available in a stable-enough version according to your minimum-stability setting\n   see <https://groups.google.com/d/topic/composer-dev/_g3ASeIFlrc/discussion> for more details.\n\nRead <https://getcomposer.org/doc/articles/troubleshooting.md> for further common problems.";
 }

 return $text;
 }

 public function getProblems()
 {
 return $this->problems;
 }
 }
 <?php











 namespace Composer\DependencyResolver;

 use Composer\Package\AliasPackage;




 class Transaction
 {
 protected $policy;
 protected $pool;
 protected $installedMap;
 protected $decisions;
 protected $transaction;

 public function __construct($policy, $pool, $installedMap, $decisions)
 {
 $this->policy = $policy;
 $this->pool = $pool;
 $this->installedMap = $installedMap;
 $this->decisions = $decisions;
 $this->transaction = array();
 }

 public function getOperations()
 {
 $installMeansUpdateMap = $this->findUpdates();

 $updateMap = array();
 $installMap = array();
 $uninstallMap = array();

 foreach ($this->decisions as $i => $decision) {
 $literal = $decision[Decisions::DECISION_LITERAL];
 $reason = $decision[Decisions::DECISION_REASON];

 $package = $this->pool->literalToPackage($literal);


 if (($literal > 0) == (isset($this->installedMap[$package->id]))) {
 continue;
 }

 if ($literal > 0) {
 if (isset($installMeansUpdateMap[abs($literal)]) && !$package instanceof AliasPackage) {
 $source = $installMeansUpdateMap[abs($literal)];

 $updateMap[$package->id] = array(
 'package' => $package,
 'source' => $source,
 'reason' => $reason,
 );


 unset($installMeansUpdateMap[abs($literal)]);
 $ignoreRemove[$source->id] = true;
 } else {
 $installMap[$package->id] = array(
 'package' => $package,
 'reason' => $reason,
 );
 }
 }
 }

 foreach ($this->decisions as $i => $decision) {
 $literal = $decision[Decisions::DECISION_LITERAL];
 $reason = $decision[Decisions::DECISION_REASON];
 $package = $this->pool->literalToPackage($literal);

 if ($literal <= 0 &&
 isset($this->installedMap[$package->id]) &&
 !isset($ignoreRemove[$package->id])) {
 $uninstallMap[$package->id] = array(
 'package' => $package,
 'reason' => $reason,
 );
 }
 }

 $this->transactionFromMaps($installMap, $updateMap, $uninstallMap);

 return $this->transaction;
 }

 protected function transactionFromMaps($installMap, $updateMap, $uninstallMap)
 {
 $queue = array_map(function ($operation) {
 return $operation['package'];
 },
 $this->findRootPackages($installMap, $updateMap)
 );

 $visited = array();

 while (!empty($queue)) {
 $package = array_pop($queue);
 $packageId = $package->id;

 if (!isset($visited[$packageId])) {
 array_push($queue, $package);

 if ($package instanceof AliasPackage) {
 array_push($queue, $package->getAliasOf());
 } else {
 foreach ($package->getRequires() as $link) {
 $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());

 foreach ($possibleRequires as $require) {
 array_push($queue, $require);
 }
 }
 }

 $visited[$package->id] = true;
 } else {
 if (isset($installMap[$packageId])) {
 $this->install(
 $installMap[$packageId]['package'],
 $installMap[$packageId]['reason']
 );
 unset($installMap[$packageId]);
 }
 if (isset($updateMap[$packageId])) {
 $this->update(
 $updateMap[$packageId]['source'],
 $updateMap[$packageId]['package'],
 $updateMap[$packageId]['reason']
 );
 unset($updateMap[$packageId]);
 }
 }
 }

 foreach ($uninstallMap as $uninstall) {
 $this->uninstall($uninstall['package'], $uninstall['reason']);
 }
 }

 protected function findRootPackages($installMap, $updateMap)
 {
 $packages = $installMap + $updateMap;
 $roots = $packages;

 foreach ($packages as $packageId => $operation) {
 $package = $operation['package'];

 if (!isset($roots[$packageId])) {
 continue;
 }

 foreach ($package->getRequires() as $link) {
 $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());

 foreach ($possibleRequires as $require) {
 unset($roots[$require->id]);
 }
 }
 }

 return $roots;
 }

 protected function findUpdates()
 {
 $installMeansUpdateMap = array();

 foreach ($this->decisions as $i => $decision) {
 $literal = $decision[Decisions::DECISION_LITERAL];
 $package = $this->pool->literalToPackage($literal);

 if ($package instanceof AliasPackage) {
 continue;
 }


 if ($literal <= 0 && isset($this->installedMap[$package->id])) {
 $updates = $this->policy->findUpdatePackages($this->pool, $this->installedMap, $package);

 $literals = array($package->id);

 foreach ($updates as $update) {
 $literals[] = $update->id;
 }

 foreach ($literals as $updateLiteral) {
 if ($updateLiteral !== $literal) {
 $installMeansUpdateMap[abs($updateLiteral)] = $package;
 }
 }
 }
 }

 return $installMeansUpdateMap;
 }

 protected function install($package, $reason)
 {
 if ($package instanceof AliasPackage) {
 return $this->markAliasInstalled($package, $reason);
 }

 $this->transaction[] = new Operation\InstallOperation($package, $reason);
 }

 protected function update($from, $to, $reason)
 {
 $this->transaction[] = new Operation\UpdateOperation($from, $to, $reason);
 }

 protected function uninstall($package, $reason)
 {
 if ($package instanceof AliasPackage) {
 return $this->markAliasUninstalled($package, $reason);
 }

 $this->transaction[] = new Operation\UninstallOperation($package, $reason);
 }

 protected function markAliasInstalled($package, $reason)
 {
 $this->transaction[] = new Operation\MarkAliasInstalledOperation($package, $reason);
 }

 protected function markAliasUninstalled($package, $reason)
 {
 $this->transaction[] = new Operation\MarkAliasUninstalledOperation($package, $reason);
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Symfony\Component\Finder\Finder;








 abstract class ArchiveDownloader extends FileDownloader
 {



 public function download(PackageInterface $package, $path)
 {
 $temporaryDir = $this->config->get('vendor-dir').'/composer/'.substr(md5(uniqid('', true)), 0, 8);
 $retries = 3;
 while ($retries--) {
 $fileName = parent::download($package, $path);

 if ($this->io->isVerbose()) {
 $this->io->writeError('    Extracting archive');
 }

 try {
 $this->filesystem->ensureDirectoryExists($temporaryDir);
 try {
 $this->extract($fileName, $temporaryDir);
 } catch (\Exception $e) {

 parent::clearCache($package, $path);
 throw $e;
 }

 $this->filesystem->unlink($fileName);

 $contentDir = $this->getFolderContent($temporaryDir);


 if (1 === count($contentDir) && is_dir(reset($contentDir))) {
 $contentDir = $this->getFolderContent((string) reset($contentDir));
 }


 foreach ($contentDir as $file) {
 $file = (string) $file;
 $this->filesystem->rename($file, $path . '/' . basename($file));
 }

 $this->filesystem->removeDirectory($temporaryDir);
 if ($this->filesystem->isDirEmpty($this->config->get('vendor-dir').'/composer/')) {
 $this->filesystem->removeDirectory($this->config->get('vendor-dir').'/composer/');
 }
 if ($this->filesystem->isDirEmpty($this->config->get('vendor-dir'))) {
 $this->filesystem->removeDirectory($this->config->get('vendor-dir'));
 }
 } catch (\Exception $e) {

 $this->filesystem->removeDirectory($path);
 $this->filesystem->removeDirectory($temporaryDir);


 if ($retries && $e instanceof \UnexpectedValueException && class_exists('ZipArchive') && $e->getCode() === \ZipArchive::ER_NOZIP) {
 if ($this->io->isDebug()) {
 $this->io->writeError('    Invalid zip file ('.$e->getMessage().'), retrying...');
 } else {
 $this->io->writeError('    Invalid zip file, retrying...');
 }
 usleep(500000);
 continue;
 }

 throw $e;
 }

 break;
 }

 $this->io->writeError('');
 }




 protected function getFileName(PackageInterface $package, $path)
 {
 return rtrim($path.'/'.md5($path.spl_object_hash($package)).'.'.pathinfo(parse_url($package->getDistUrl(), PHP_URL_PATH), PATHINFO_EXTENSION), '.');
 }




 protected function processUrl(PackageInterface $package, $url)
 {
 if ($package->getDistReference() && strpos($url, 'github.com')) {
 if (preg_match('{^https?://(?:www\.)?github\.com/([^/]+)/([^/]+)/(zip|tar)ball/(.+)$}i', $url, $match)) {

 $url = 'https://api.github.com/repos/' . $match[1] . '/'. $match[2] . '/' . $match[3] . 'ball/' . $package->getDistReference();
 } elseif ($package->getDistReference() && preg_match('{^https?://(?:www\.)?github\.com/([^/]+)/([^/]+)/archive/.+\.(zip|tar)(?:\.gz)?$}i', $url, $match)) {

 $url = 'https://api.github.com/repos/' . $match[1] . '/'. $match[2] . '/' . $match[3] . 'ball/' . $package->getDistReference();
 } elseif ($package->getDistReference() && preg_match('{^https?://api\.github\.com/repos/([^/]+)/([^/]+)/(zip|tar)ball(?:/.+)?$}i', $url, $match)) {

 $url = 'https://api.github.com/repos/' . $match[1] . '/'. $match[2] . '/' . $match[3] . 'ball/' . $package->getDistReference();
 }
 } elseif ($package->getDistReference() && strpos($url, 'bitbucket.org')) {
 if (preg_match('{^https?://(?:www\.)?bitbucket\.org/([^/]+)/([^/]+)/get/(.+)\.(zip|tar\.gz|tar\.bz2)$}i', $url, $match)) {

 $url = 'https://bitbucket.org/' . $match[1] . '/'. $match[2] . '/get/' . $package->getDistReference() . '.' . $match[4];
 }
 }

 return parent::processUrl($package, $url);
 }









 abstract protected function extract($file, $path);







 private function getFolderContent($dir)
 {
 $finder = Finder::create()
 ->ignoreVCS(false)
 ->ignoreDotFiles(false)
 ->depth(0)
 ->in($dir);

 return iterator_to_array($finder);
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;






 interface ChangeReportInterface
 {







 public function getLocalChanges(PackageInterface $package, $path);
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Composer\IO\IOInterface;
 use Composer\Util\Filesystem;






 class DownloadManager
 {
 private $io;
 private $preferDist = false;
 private $preferSource = false;
 private $filesystem;
 private $downloaders = array();








 public function __construct(IOInterface $io, $preferSource = false, Filesystem $filesystem = null)
 {
 $this->io = $io;
 $this->preferSource = $preferSource;
 $this->filesystem = $filesystem ?: new Filesystem();
 }







 public function setPreferSource($preferSource)
 {
 $this->preferSource = $preferSource;

 return $this;
 }







 public function setPreferDist($preferDist)
 {
 $this->preferDist = $preferDist;

 return $this;
 }








 public function setOutputProgress($outputProgress)
 {
 foreach ($this->downloaders as $downloader) {
 $downloader->setOutputProgress($outputProgress);
 }

 return $this;
 }








 public function setDownloader($type, DownloaderInterface $downloader)
 {
 $type = strtolower($type);
 $this->downloaders[$type] = $downloader;

 return $this;
 }









 public function getDownloader($type)
 {
 $type = strtolower($type);
 if (!isset($this->downloaders[$type])) {
 throw new \InvalidArgumentException(sprintf('Unknown downloader type: %s. Available types: %s.', $type, implode(', ', array_keys($this->downloaders))));
 }

 return $this->downloaders[$type];
 }











 public function getDownloaderForInstalledPackage(PackageInterface $package)
 {
 $installationSource = $package->getInstallationSource();

 if ('metapackage' === $package->getType()) {
 return;
 }

 if ('dist' === $installationSource) {
 $downloader = $this->getDownloader($package->getDistType());
 } elseif ('source' === $installationSource) {
 $downloader = $this->getDownloader($package->getSourceType());
 } else {
 throw new \InvalidArgumentException(
 'Package '.$package.' seems not been installed properly'
 );
 }

 if ($installationSource !== $downloader->getInstallationSource()) {
 throw new \LogicException(sprintf(
 'Downloader "%s" is a %s type downloader and can not be used to download %s',
 get_class($downloader), $downloader->getInstallationSource(), $installationSource
 ));
 }

 return $downloader;
 }











 public function download(PackageInterface $package, $targetDir, $preferSource = null)
 {
 $preferSource = null !== $preferSource ? $preferSource : $this->preferSource;
 $sourceType = $package->getSourceType();
 $distType = $package->getDistType();

 $sources = array();
 if ($sourceType) {
 $sources[] = 'source';
 }
 if ($distType) {
 $sources[] = 'dist';
 }

 if (empty($sources)) {
 throw new \InvalidArgumentException('Package '.$package.' must have a source or dist specified');
 }

 if ((!$package->isDev() || $this->preferDist) && !$preferSource) {
 $sources = array_reverse($sources);
 }

 $this->filesystem->ensureDirectoryExists($targetDir);

 foreach ($sources as $i => $source) {
 if (isset($e)) {
 $this->io->writeError('    <warning>Now trying to download from ' . $source . '</warning>');
 }
 $package->setInstallationSource($source);
 try {
 $downloader = $this->getDownloaderForInstalledPackage($package);
 if ($downloader) {
 $downloader->download($package, $targetDir);
 }
 break;
 } catch (\RuntimeException $e) {
 if ($i === count($sources) - 1) {
 throw $e;
 }

 $this->io->writeError(
 '    <warning>Failed to download '.
 $package->getPrettyName().
 ' from ' . $source . ': '.
 $e->getMessage().'</warning>'
 );
 }
 }
 }










 public function update(PackageInterface $initial, PackageInterface $target, $targetDir)
 {
 $downloader = $this->getDownloaderForInstalledPackage($initial);
 if (!$downloader) {
 return;
 }

 $installationSource = $initial->getInstallationSource();

 if ('dist' === $installationSource) {
 $initialType = $initial->getDistType();
 $targetType = $target->getDistType();
 } else {
 $initialType = $initial->getSourceType();
 $targetType = $target->getSourceType();
 }


 if ($target->isDev() && 'dist' === $installationSource) {
 $downloader->remove($initial, $targetDir);
 $this->download($target, $targetDir);

 return;
 }

 if ($initialType === $targetType) {
 $target->setInstallationSource($installationSource);
 $downloader->update($initial, $target, $targetDir);
 } else {
 $downloader->remove($initial, $targetDir);
 $this->download($target, $targetDir, 'source' === $installationSource);
 }
 }







 public function remove(PackageInterface $package, $targetDir)
 {
 $downloader = $this->getDownloaderForInstalledPackage($package);
 if ($downloader) {
 $downloader->remove($package, $targetDir);
 }
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;







 interface DownloaderInterface
 {





 public function getInstallationSource();







 public function download(PackageInterface $package, $path);








 public function update(PackageInterface $initial, PackageInterface $target, $path);







 public function remove(PackageInterface $package, $path);







 public function setOutputProgress($outputProgress);
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Config;
 use Composer\Cache;
 use Composer\IO\IOInterface;
 use Composer\Package\PackageInterface;
 use Composer\Plugin\PluginEvents;
 use Composer\Plugin\PreFileDownloadEvent;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Util\Filesystem;
 use Composer\Util\RemoteFilesystem;









 class FileDownloader implements DownloaderInterface
 {
 protected $io;
 protected $config;
 protected $rfs;
 protected $filesystem;
 protected $cache;
 protected $outputProgress = true;











 public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, Cache $cache = null, RemoteFilesystem $rfs = null, Filesystem $filesystem = null)
 {
 $this->io = $io;
 $this->config = $config;
 $this->eventDispatcher = $eventDispatcher;
 $this->rfs = $rfs ?: new RemoteFilesystem($io, $config);
 $this->filesystem = $filesystem ?: new Filesystem();
 $this->cache = $cache;

 if ($this->cache && $this->cache->gcIsNecessary()) {
 $this->cache->gc($config->get('cache-files-ttl'), $config->get('cache-files-maxsize'));
 }
 }




 public function getInstallationSource()
 {
 return 'dist';
 }




 public function download(PackageInterface $package, $path)
 {
 if (!$package->getDistUrl()) {
 throw new \InvalidArgumentException('The given package is missing url information');
 }

 $this->io->writeError("  - Installing <info>" . $package->getName() . "</info> (<comment>" . $package->getFullPrettyVersion() . "</comment>)");

 $urls = $package->getDistUrls();
 while ($url = array_shift($urls)) {
 try {
 return $this->doDownload($package, $path, $url);
 } catch (\Exception $e) {
 if ($this->io->isDebug()) {
 $this->io->writeError('');
 $this->io->writeError('Failed: ['.get_class($e).'] '.$e->getCode().': '.$e->getMessage());
 } elseif (count($urls)) {
 $this->io->writeError('');
 $this->io->writeError('    Failed, trying the next URL ('.$e->getCode().': '.$e->getMessage().')');
 }

 if (!count($urls)) {
 throw $e;
 }
 }
 }

 $this->io->writeError('');
 }

 protected function doDownload(PackageInterface $package, $path, $url)
 {
 $this->filesystem->emptyDirectory($path);

 $fileName = $this->getFileName($package, $path);

 $processedUrl = $this->processUrl($package, $url);
 $hostname = parse_url($processedUrl, PHP_URL_HOST);

 $preFileDownloadEvent = new PreFileDownloadEvent(PluginEvents::PRE_FILE_DOWNLOAD, $this->rfs, $processedUrl);
 if ($this->eventDispatcher) {
 $this->eventDispatcher->dispatch($preFileDownloadEvent->getName(), $preFileDownloadEvent);
 }
 $rfs = $preFileDownloadEvent->getRemoteFilesystem();

 try {
 $checksum = $package->getDistSha1Checksum();
 $cacheKey = $this->getCacheKey($package);


 if (!$this->cache || ($checksum && $checksum !== $this->cache->sha1($cacheKey)) || !$this->cache->copyTo($cacheKey, $fileName)) {
 if (!$this->outputProgress) {
 $this->io->writeError('    Downloading');
 }


 $retries = 3;
 while ($retries--) {
 try {
 $rfs->copy($hostname, $processedUrl, $fileName, $this->outputProgress, $package->getTransportOptions());
 break;
 } catch (TransportException $e) {

 if ((0 !== $e->getCode() && !in_array($e->getCode(),array(500, 502, 503, 504))) || !$retries) {
 throw $e;
 }
 if ($this->io->isVerbose()) {
 $this->io->writeError('    Download failed, retrying...');
 }
 usleep(500000);
 }
 }

 if ($this->cache) {
 $this->cache->copyFrom($cacheKey, $fileName);
 }
 } else {
 $this->io->writeError('    Loading from cache');
 }

 if (!file_exists($fileName)) {
 throw new \UnexpectedValueException($url.' could not be saved to '.$fileName.', make sure the'
 .' directory is writable and you have internet connectivity');
 }

 if ($checksum && hash_file('sha1', $fileName) !== $checksum) {
 throw new \UnexpectedValueException('The checksum verification of the file failed (downloaded from '.$url.')');
 }
 } catch (\Exception $e) {

 $this->filesystem->removeDirectory($path);
 $this->clearCache($package, $path);
 throw $e;
 }

 return $fileName;
 }




 public function setOutputProgress($outputProgress)
 {
 $this->outputProgress = $outputProgress;

 return $this;
 }

 protected function clearCache(PackageInterface $package, $path)
 {
 if ($this->cache) {
 $fileName = $this->getFileName($package, $path);
 $this->cache->remove($this->getCacheKey($package));
 }
 }




 public function update(PackageInterface $initial, PackageInterface $target, $path)
 {
 $this->remove($initial, $path);
 $this->download($target, $path);
 }




 public function remove(PackageInterface $package, $path)
 {
 $this->io->writeError("  - Removing <info>" . $package->getName() . "</info> (<comment>" . $package->getFullPrettyVersion() . "</comment>)");
 if (!$this->filesystem->removeDirectory($path)) {
 throw new \RuntimeException('Could not completely delete '.$path.', aborting.');
 }
 }








 protected function getFileName(PackageInterface $package, $path)
 {
 return $path.'/'.pathinfo(parse_url($package->getDistUrl(), PHP_URL_PATH), PATHINFO_BASENAME);
 }










 protected function processUrl(PackageInterface $package, $url)
 {
 if (!extension_loaded('openssl') && 0 === strpos($url, 'https:')) {
 throw new \RuntimeException('You must enable the openssl extension to download files via https');
 }

 return $url;
 }

 private function getCacheKey(PackageInterface $package)
 {
 if (preg_match('{^[a-f0-9]{40}$}', $package->getDistReference())) {
 return $package->getName().'/'.$package->getDistReference().'.'.$package->getDistType();
 }

 return $package->getName().'/'.$package->getVersion().'-'.$package->getDistReference().'.'.$package->getDistType();
 }
 }
 <?php











 namespace Composer\Downloader;






 class FilesystemException extends \Exception
 {
 public function __construct($message = null, $code = null, \Exception $previous = null)
 {
 parent::__construct("Filesystem exception: \n".$message, $code, $previous);
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Composer\Util\Git as GitUtil;
 use Composer\Util\ProcessExecutor;
 use Composer\IO\IOInterface;
 use Composer\Util\Filesystem;
 use Composer\Config;




 class GitDownloader extends VcsDownloader
 {
 private $hasStashedChanges = false;
 private $gitUtil;

 public function __construct(IOInterface $io, Config $config, ProcessExecutor $process = null, Filesystem $fs = null)
 {
 parent::__construct($io, $config, $process, $fs);
 $this->gitUtil = new GitUtil($this->io, $this->config, $this->process, $this->filesystem);
 }




 public function doDownload(PackageInterface $package, $path, $url)
 {
 GitUtil::cleanEnv();
 $path = $this->normalizePath($path);

 $ref = $package->getSourceReference();
 $flag = defined('PHP_WINDOWS_VERSION_MAJOR') ? '/D ' : '';
 $command = 'git clone --no-checkout %s %s && cd '.$flag.'%2$s && git remote add composer %1$s && git fetch composer';
 $this->io->writeError("    Cloning ".$ref);

 $commandCallable = function ($url) use ($ref, $path, $command) {
 return sprintf($command, ProcessExecutor::escape($url), ProcessExecutor::escape($path), ProcessExecutor::escape($ref));
 };

 $this->gitUtil->runCommand($commandCallable, $url, $path, true);
 if ($url !== $package->getSourceUrl()) {
 $url = $package->getSourceUrl();
 $this->process->execute(sprintf('git remote set-url origin %s', ProcessExecutor::escape($url)), $output, $path);
 }
 $this->setPushUrl($path, $url);

 if ($newRef = $this->updateToCommit($path, $ref, $package->getPrettyVersion(), $package->getReleaseDate())) {
 if ($package->getDistReference() === $package->getSourceReference()) {
 $package->setDistReference($newRef);
 }
 $package->setSourceReference($newRef);
 }
 }




 public function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url)
 {
 GitUtil::cleanEnv();
 $path = $this->normalizePath($path);
 if (!is_dir($path.'/.git')) {
 throw new \RuntimeException('The .git directory is missing from '.$path.', see https://getcomposer.org/commit-deps for more information');
 }

 $ref = $target->getSourceReference();
 $this->io->writeError("    Checking out ".$ref);
 $command = 'git remote set-url composer %s && git fetch composer && git fetch --tags composer';

 $commandCallable = function ($url) use ($command) {
 return sprintf($command, ProcessExecutor::escape($url));
 };

 $this->gitUtil->runCommand($commandCallable, $url, $path);
 if ($newRef = $this->updateToCommit($path, $ref, $target->getPrettyVersion(), $target->getReleaseDate())) {
 if ($target->getDistReference() === $target->getSourceReference()) {
 $target->setDistReference($newRef);
 }
 $target->setSourceReference($newRef);
 }
 }




 public function getLocalChanges(PackageInterface $package, $path)
 {
 GitUtil::cleanEnv();
 $path = $this->normalizePath($path);
 if (!is_dir($path.'/.git')) {
 return;
 }

 $command = 'git status --porcelain --untracked-files=no';
 if (0 !== $this->process->execute($command, $output, $path)) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }

 return trim($output) ?: null;
 }




 protected function cleanChanges(PackageInterface $package, $path, $update)
 {
 GitUtil::cleanEnv();
 $path = $this->normalizePath($path);
 if (!$changes = $this->getLocalChanges($package, $path)) {
 return;
 }

 if (!$this->io->isInteractive()) {
 $discardChanges = $this->config->get('discard-changes');
 if (true === $discardChanges) {
 return $this->discardChanges($path);
 }
 if ('stash' === $discardChanges) {
 if (!$update) {
 return parent::cleanChanges($package, $path, $update);
 }

 return $this->stashChanges($path);
 }

 return parent::cleanChanges($package, $path, $update);
 }

 $changes = array_map(function ($elem) {
 return '    '.$elem;
 }, preg_split('{\s*\r?\n\s*}', $changes));
 $this->io->writeError('    <error>The package has modified files:</error>');
 $this->io->writeError(array_slice($changes, 0, 10));
 if (count($changes) > 10) {
 $this->io->writeError('    <info>'.count($changes) - 10 . ' more files modified, choose "v" to view the full list</info>');
 }

 while (true) {
 switch ($this->io->ask('    <info>Discard changes [y,n,v,d,'.($update ? 's,' : '').'?]?</info> ', '?')) {
 case 'y':
 $this->discardChanges($path);
 break 2;

 case 's':
 if (!$update) {
 goto help;
 }

 $this->stashChanges($path);
 break 2;

 case 'n':
 throw new \RuntimeException('Update aborted');

 case 'v':
 $this->io->writeError($changes);
 break;

 case 'd':
 $this->viewDiff($path);
 break;

 case '?':
 default:
 help:
 $this->io->writeError(array(
 '    y - discard changes and apply the '.($update ? 'update' : 'uninstall'),
 '    n - abort the '.($update ? 'update' : 'uninstall').' and let you manually clean things up',
 '    v - view modified files',
 '    d - view local modifications (diff)',
 ));
 if ($update) {
 $this->io->writeError('    s - stash changes and try to reapply them after the update');
 }
 $this->io->writeError('    ? - print help');
 break;
 }
 }
 }




 protected function reapplyChanges($path)
 {
 $path = $this->normalizePath($path);
 if ($this->hasStashedChanges) {
 $this->hasStashedChanges = false;
 $this->io->writeError('    <info>Re-applying stashed changes</info>');
 if (0 !== $this->process->execute('git stash pop', $output, $path)) {
 throw new \RuntimeException("Failed to apply stashed changes:\n\n".$this->process->getErrorOutput());
 }
 }
 }












 protected function updateToCommit($path, $reference, $branch, $date)
 {

 
 
 
 
 $template = 'git checkout %s -- && git reset --hard %1$s --';
 $branch = preg_replace('{(?:^dev-|(?:\.x)?-dev$)}i', '', $branch);

 $branches = null;
 if (0 === $this->process->execute('git branch -r', $output, $path)) {
 $branches = $output;
 }


 $gitRef = $reference;
 if (!preg_match('{^[a-f0-9]{40}$}', $reference)
 && $branches
 && preg_match('{^\s+composer/'.preg_quote($reference).'$}m', $branches)
 ) {
 $command = sprintf('git checkout -B %s %s -- && git reset --hard %2$s --', ProcessExecutor::escape($branch), ProcessExecutor::escape('composer/'.$reference));
 if (0 === $this->process->execute($command, $output, $path)) {
 return;
 }
 }


 if (preg_match('{^[a-f0-9]{40}$}', $reference)) {

 if (!preg_match('{^\s+composer/'.preg_quote($branch).'$}m', $branches) && preg_match('{^\s+composer/v'.preg_quote($branch).'$}m', $branches)) {
 $branch = 'v' . $branch;
 }

 $command = sprintf('git checkout %s --', ProcessExecutor::escape($branch));
 $fallbackCommand = sprintf('git checkout -B %s %s --', ProcessExecutor::escape($branch), ProcessExecutor::escape('composer/'.$branch));
 if (0 === $this->process->execute($command, $output, $path)
 || 0 === $this->process->execute($fallbackCommand, $output, $path)
 ) {
 $command = sprintf('git reset --hard %s --', ProcessExecutor::escape($reference));
 if (0 === $this->process->execute($command, $output, $path)) {
 return;
 }
 }
 }

 $command = sprintf($template, ProcessExecutor::escape($gitRef));
 if (0 === $this->process->execute($command, $output, $path)) {
 return;
 }


 if (false !== strpos($this->process->getErrorOutput(), $reference)) {
 $this->io->writeError('    <warning>'.$reference.' is gone (history was rewritten?)</warning>');
 }

 throw new \RuntimeException('Failed to execute ' . GitUtil::sanitizeUrl($command) . "\n\n" . $this->process->getErrorOutput());
 }

 protected function setPushUrl($path, $url)
 {

 if (preg_match('{^(?:https?|git)://'.GitUtil::getGitHubDomainsRegex($this->config).'/([^/]+)/([^/]+?)(?:\.git)?$}', $url, $match)) {
 $protocols = $this->config->get('github-protocols');
 $pushUrl = 'git@'.$match[1].':'.$match[2].'/'.$match[3].'.git';
 if ($protocols[0] !== 'git') {
 $pushUrl = 'https://' . $match[1] . '/'.$match[2].'/'.$match[3].'.git';
 }
 $cmd = sprintf('git remote set-url --push origin %s', ProcessExecutor::escape($pushUrl));
 $this->process->execute($cmd, $ignoredOutput, $path);
 }
 }




 protected function getCommitLogs($fromReference, $toReference, $path)
 {
 $path = $this->normalizePath($path);
 $command = sprintf('git log %s..%s --pretty=format:"%%h - %%an: %%s"', $fromReference, $toReference);

 if (0 !== $this->process->execute($command, $output, $path)) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }

 return $output;
 }





 protected function discardChanges($path)
 {
 $path = $this->normalizePath($path);
 if (0 !== $this->process->execute('git reset --hard', $output, $path)) {
 throw new \RuntimeException("Could not reset changes\n\n:".$this->process->getErrorOutput());
 }
 }





 protected function stashChanges($path)
 {
 $path = $this->normalizePath($path);
 if (0 !== $this->process->execute('git stash', $output, $path)) {
 throw new \RuntimeException("Could not stash changes\n\n:".$this->process->getErrorOutput());
 }

 $this->hasStashedChanges = true;
 }





 protected function viewDiff($path)
 {
 $path = $this->normalizePath($path);
 if (0 !== $this->process->execute('git diff HEAD', $output, $path)) {
 throw new \RuntimeException("Could not view diff\n\n:".$this->process->getErrorOutput());
 }

 $this->io->writeError($output);
 }

 protected function normalizePath($path)
 {
 if (defined('PHP_WINDOWS_VERSION_MAJOR') && strlen($path) > 0) {
 $basePath = $path;
 $removed = array();

 while (!is_dir($basePath) && $basePath !== '\\') {
 array_unshift($removed, basename($basePath));
 $basePath = dirname($basePath);
 }

 if ($basePath === '\\') {
 return $path;
 }

 $path = rtrim(realpath($basePath) . '/' . implode('/', $removed), '/');
 }

 return $path;
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Config;
 use Composer\Cache;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Package\PackageInterface;
 use Composer\Util\ProcessExecutor;
 use Composer\IO\IOInterface;






 class GzipDownloader extends ArchiveDownloader
 {
 protected $process;

 public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, Cache $cache = null, ProcessExecutor $process = null)
 {
 $this->process = $process ?: new ProcessExecutor($io);
 parent::__construct($io, $config, $eventDispatcher, $cache);
 }

 protected function extract($file, $path)
 {
 $targetFilepath = $path . DIRECTORY_SEPARATOR . basename(substr($file, 0, -3));


 if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
 $command = 'gzip -cd ' . ProcessExecutor::escape($file) . ' > ' . ProcessExecutor::escape($targetFilepath);

 if (0 === $this->process->execute($command, $ignoredOutput)) {
 return;
 }

 $processError = 'Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput();
 throw new \RuntimeException($processError);
 }


 $archiveFile = gzopen($file, 'rb');
 $targetFile = fopen($targetFilepath, 'wb');
 while ($string = gzread($archiveFile, 4096)) {
 fwrite($targetFile, $string, strlen($string));
 }
 gzclose($archiveFile);
 fclose($targetFile);
 }




 protected function getFileName(PackageInterface $package, $path)
 {
 return $path.'/'.pathinfo(parse_url($package->getDistUrl(), PHP_URL_PATH), PATHINFO_BASENAME);
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Composer\Util\ProcessExecutor;




 class HgDownloader extends VcsDownloader
 {



 public function doDownload(PackageInterface $package, $path, $url)
 {
 $url = ProcessExecutor::escape($url);
 $ref = ProcessExecutor::escape($package->getSourceReference());
 $this->io->writeError("    Cloning ".$package->getSourceReference());
 $command = sprintf('hg clone %s %s', $url, ProcessExecutor::escape($path));
 if (0 !== $this->process->execute($command, $ignoredOutput)) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }
 $command = sprintf('hg up %s', $ref);
 if (0 !== $this->process->execute($command, $ignoredOutput, realpath($path))) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }
 }




 public function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url)
 {
 $url = ProcessExecutor::escape($url);
 $ref = ProcessExecutor::escape($target->getSourceReference());
 $this->io->writeError("    Updating to ".$target->getSourceReference());

 if (!is_dir($path.'/.hg')) {
 throw new \RuntimeException('The .hg directory is missing from '.$path.', see https://getcomposer.org/commit-deps for more information');
 }

 $command = sprintf('hg pull %s && hg up %s', $url, $ref);
 if (0 !== $this->process->execute($command, $ignoredOutput, realpath($path))) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }
 }




 public function getLocalChanges(PackageInterface $package, $path)
 {
 if (!is_dir($path.'/.hg')) {
 return;
 }

 $this->process->execute('hg st', $output, realpath($path));

 return trim($output) ?: null;
 }




 protected function getCommitLogs($fromReference, $toReference, $path)
 {
 $command = sprintf('hg log -r %s:%s --style compact', $fromReference, $toReference);

 if (0 !== $this->process->execute($command, $output, realpath($path))) {
 throw new \RuntimeException('Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput());
 }

 return $output;
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Util\Filesystem;










 class PearPackageExtractor
 {
 private static $rolesWithoutPackageNamePrefix = array('php', 'script', 'www');

 private $filesystem;
 private $file;

 public function __construct($file)
 {
 if (!is_file($file)) {
 throw new \UnexpectedValueException('PEAR package file is not found at '.$file);
 }

 $this->filesystem = new Filesystem();
 $this->file = $file;
 }











 public function extractTo($target, array $roles = array('php' => '/', 'script' => '/bin'), $vars = array())
 {
 $extractionPath = $target.'/tarball';

 try {
 $archive = new \PharData($this->file);
 $archive->extractTo($extractionPath, null, true);

 if (!is_file($this->combine($extractionPath, '/package.xml'))) {
 throw new \RuntimeException('Invalid PEAR package. It must contain package.xml file.');
 }

 $fileCopyActions = $this->buildCopyActions($extractionPath, $roles, $vars);
 $this->copyFiles($fileCopyActions, $extractionPath, $target, $roles, $vars);
 $this->filesystem->removeDirectory($extractionPath);
 } catch (\Exception $exception) {
 throw new \UnexpectedValueException(sprintf('Failed to extract PEAR package %s to %s. Reason: %s', $this->file, $target, $exception->getMessage()), 0, $exception);
 }
 }










 private function copyFiles($files, $source, $target, $roles, $vars)
 {
 foreach ($files as $file) {
 $from = $this->combine($source, $file['from']);
 $to = $this->combine($target, $roles[$file['role']]);
 $to = $this->combine($to, $file['to']);
 $tasks = $file['tasks'];
 $this->copyFile($from, $to, $tasks, $vars);
 }
 }

 private function copyFile($from, $to, $tasks, $vars)
 {
 if (!is_file($from)) {
 throw new \RuntimeException('Invalid PEAR package. package.xml defines file that is not located inside tarball.');
 }

 $this->filesystem->ensureDirectoryExists(dirname($to));

 if (0 == count($tasks)) {
 $copied = copy($from, $to);
 } else {
 $content = file_get_contents($from);
 $replacements = array();
 foreach ($tasks as $task) {
 $pattern = $task['from'];
 $varName = $task['to'];
 if (isset($vars[$varName])) {
 if ($varName === 'php_bin' && false === strpos($to, '.bat')) {
 $replacements[$pattern] = preg_replace('{\.bat$}', '', $vars[$varName]);
 } else {
 $replacements[$pattern] = $vars[$varName];
 }
 }
 }
 $content = strtr($content, $replacements);

 $copied = file_put_contents($to, $content);
 }

 if (false === $copied) {
 throw new \RuntimeException(sprintf('Failed to copy %s to %s', $from, $to));
 }
 }











 private function buildCopyActions($source, array $roles, $vars)
 {

 $package = simplexml_load_string(file_get_contents($this->combine($source, 'package.xml')));
 if (false === $package) {
 throw new \RuntimeException('Package definition file is not valid.');
 }

 $packageSchemaVersion = $package['version'];
 if ('1.0' == $packageSchemaVersion) {
 $children = $package->release->filelist->children();
 $packageName = (string) $package->name;
 $packageVersion = (string) $package->release->version;
 $sourceDir = $packageName . '-' . $packageVersion;
 $result = $this->buildSourceList10($children, $roles, $sourceDir, '', null, $packageName);
 } elseif ('2.0' == $packageSchemaVersion || '2.1' == $packageSchemaVersion) {
 $children = $package->contents->children();
 $packageName = (string) $package->name;
 $packageVersion = (string) $package->version->release;
 $sourceDir = $packageName . '-' . $packageVersion;
 $result = $this->buildSourceList20($children, $roles, $sourceDir, '', null, $packageName);

 $namespaces = $package->getNamespaces();
 $package->registerXPathNamespace('ns', $namespaces['']);
 $releaseNodes = $package->xpath('ns:phprelease');
 $this->applyRelease($result, $releaseNodes, $vars);
 } else {
 throw new \RuntimeException('Unsupported schema version of package definition file.');
 }

 return $result;
 }

 private function applyRelease(&$actions, $releaseNodes, $vars)
 {
 foreach ($releaseNodes as $releaseNode) {
 $requiredOs = $releaseNode->installconditions && $releaseNode->installconditions->os && $releaseNode->installconditions->os->name ? (string) $releaseNode->installconditions->os->name : '';
 if ($requiredOs && $vars['os'] != $requiredOs) {
 continue;
 }

 if ($releaseNode->filelist) {
 foreach ($releaseNode->filelist->children() as $action) {
 if ('install' == $action->getName()) {
 $name = (string) $action['name'];
 $as = (string) $action['as'];
 if (isset($actions[$name])) {
 $actions[$name]['to'] = $as;
 }
 } elseif ('ignore' == $action->getName()) {
 $name = (string) $action['name'];
 unset($actions[$name]);
 } else {

 }
 }
 }
 break;
 }
 }

 private function buildSourceList10($children, $targetRoles, $source, $target, $role, $packageName)
 {
 $result = array();


 foreach ($children as $child) {

 if ($child->getName() == 'dir') {
 $dirSource = $this->combine($source, (string) $child['name']);
 $dirTarget = $child['baseinstalldir'] ?: $target;
 $dirRole = $child['role'] ?: $role;
 $dirFiles = $this->buildSourceList10($child->children(), $targetRoles, $dirSource, $dirTarget, $dirRole, $packageName);
 $result = array_merge($result, $dirFiles);
 } elseif ($child->getName() == 'file') {
 $fileRole = (string) $child['role'] ?: $role;
 if (isset($targetRoles[$fileRole])) {
 $fileName = (string) ($child['name'] ?: $child[0]); 
 $fileSource = $this->combine($source, $fileName);
 $fileTarget = $this->combine((string) $child['baseinstalldir'] ?: $target, $fileName);
 if (!in_array($fileRole, self::$rolesWithoutPackageNamePrefix)) {
 $fileTarget = $packageName . '/' . $fileTarget;
 }
 $result[(string) $child['name']] = array('from' => $fileSource, 'to' => $fileTarget, 'role' => $fileRole, 'tasks' => array());
 }
 }
 }

 return $result;
 }

 private function buildSourceList20($children, $targetRoles, $source, $target, $role, $packageName)
 {
 $result = array();


 foreach ($children as $child) {

 if ('dir' == $child->getName()) {
 $dirSource = $this->combine($source, $child['name']);
 $dirTarget = $child['baseinstalldir'] ?: $target;
 $dirRole = $child['role'] ?: $role;
 $dirFiles = $this->buildSourceList20($child->children(), $targetRoles, $dirSource, $dirTarget, $dirRole, $packageName);
 $result = array_merge($result, $dirFiles);
 } elseif ('file' == $child->getName()) {
 $fileRole = (string) $child['role'] ?: $role;
 if (isset($targetRoles[$fileRole])) {
 $fileSource = $this->combine($source, (string) $child['name']);
 $fileTarget = $this->combine((string) ($child['baseinstalldir'] ?: $target), (string) $child['name']);
 $fileTasks = array();
 foreach ($child->children('http://pear.php.net/dtd/tasks-1.0') as $taskNode) {
 if ('replace' == $taskNode->getName()) {
 $fileTasks[] = array('from' => (string) $taskNode->attributes()->from, 'to' => (string) $taskNode->attributes()->to);
 }
 }
 if (!in_array($fileRole, self::$rolesWithoutPackageNamePrefix)) {
 $fileTarget = $packageName . '/' . $fileTarget;
 }
 $result[(string) $child['name']] = array('from' => $fileSource, 'to' => $fileTarget, 'role' => $fileRole, 'tasks' => $fileTasks);
 }
 }
 }

 return $result;
 }

 private function combine($left, $right)
 {
 return rtrim($left, '/') . '/' . ltrim($right, '/');
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Composer\Repository\VcsRepository;
 use Composer\Util\Perforce;




 class PerforceDownloader extends VcsDownloader
 {
 protected $perforce;




 public function doDownload(PackageInterface $package, $path, $url)
 {
 $ref = $package->getSourceReference();
 $label = $this->getLabelFromSourceReference($ref);

 $this->io->writeError('    Cloning ' . $ref);
 $this->initPerforce($package, $path, $url);
 $this->perforce->setStream($ref);
 $this->perforce->p4Login($this->io);
 $this->perforce->writeP4ClientSpec();
 $this->perforce->connectClient();
 $this->perforce->syncCodeBase($label);
 $this->perforce->cleanupClientSpec();
 }

 private function getLabelFromSourceReference($ref)
 {
 $pos = strpos($ref,'@');
 if (false !== $pos) {
 return substr($ref, $pos + 1);
 }

 return null;
 }

 public function initPerforce($package, $path, $url)
 {
 if (!empty($this->perforce)) {
 $this->perforce->initializePath($path);

 return;
 }

 $repository = $package->getRepository();
 $repoConfig = null;
 if ($repository instanceof VcsRepository) {
 $repoConfig = $this->getRepoConfig($repository);
 }
 $this->perforce = Perforce::create($repoConfig, $url, $path, $this->process, $this->io);
 }

 private function getRepoConfig(VcsRepository $repository)
 {
 return $repository->getRepoConfig();
 }




 public function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url)
 {
 $this->doDownload($target, $path, $url);
 }




 public function getLocalChanges(PackageInterface $package, $path)
 {
 $this->io->writeError('Perforce driver does not check for local changes before overriding', true);

 return;
 }




 protected function getCommitLogs($fromReference, $toReference, $path)
 {
 $commitLogs = $this->perforce->getCommitLogs($fromReference, $toReference);

 return $commitLogs;
 }

 public function setPerforce($perforce)
 {
 $this->perforce = $perforce;
 }
 }
 <?php











 namespace Composer\Downloader;






 class PharDownloader extends ArchiveDownloader
 {



 protected function extract($file, $path)
 {

 $archive = new \Phar($file);
 $archive->extractTo($path, null, true);





 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Config;
 use Composer\Cache;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Util\ProcessExecutor;
 use Composer\IO\IOInterface;
 use RarArchive;








 class RarDownloader extends ArchiveDownloader
 {
 protected $process;

 public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, Cache $cache = null, ProcessExecutor $process = null)
 {
 $this->process = $process ?: new ProcessExecutor($io);
 parent::__construct($io, $config, $eventDispatcher, $cache);
 }

 protected function extract($file, $path)
 {
 $processError = null;


 if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
 $command = 'unrar x ' . ProcessExecutor::escape($file) . ' ' . ProcessExecutor::escape($path) . ' && chmod -R u+w ' . ProcessExecutor::escape($path);

 if (0 === $this->process->execute($command, $ignoredOutput)) {
 return;
 }

 $processError = 'Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput();
 }

 if (!class_exists('RarArchive')) {

 $iniPath = php_ini_loaded_file();

 if ($iniPath) {
 $iniMessage = 'The php.ini used by your command-line PHP is: ' . $iniPath;
 } else {
 $iniMessage = 'A php.ini file does not exist. You will have to create one.';
 }

 $error = "Could not decompress the archive, enable the PHP rar extension or install unrar.\n"
 . $iniMessage . "\n" . $processError;

 if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
 $error = "Could not decompress the archive, enable the PHP rar extension.\n" . $iniMessage;
 }

 throw new \RuntimeException($error);
 }

 $rarArchive = RarArchive::open($file);

 if (false === $rarArchive) {
 throw new \UnexpectedValueException('Could not open RAR archive: ' . $file);
 }

 $entries = $rarArchive->getEntries();

 if (false === $entries) {
 throw new \RuntimeException('Could not retrieve RAR archive entries');
 }

 foreach ($entries as $entry) {
 if (false === $entry->extract($path)) {
 throw new \RuntimeException('Could not extract entry');
 }
 }

 $rarArchive->close();
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Package\PackageInterface;
 use Composer\Util\Svn as SvnUtil;





 class SvnDownloader extends VcsDownloader
 {



 public function doDownload(PackageInterface $package, $path, $url)
 {
 SvnUtil::cleanEnv();
 $ref = $package->getSourceReference();

 $this->io->writeError("    Checking out ".$package->getSourceReference());
 $this->execute($url, "svn co", sprintf("%s/%s", $url, $ref), null, $path);
 }




 public function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url)
 {
 SvnUtil::cleanEnv();
 $ref = $target->getSourceReference();

 if (!is_dir($path.'/.svn')) {
 throw new \RuntimeException('The .svn directory is missing from '.$path.', see https://getcomposer.org/commit-deps for more information');
 }

 $flags = "";
 if (0 === $this->process->execute('svn --version', $output)) {
 if (preg_match('{(\d+(?:\.\d+)+)}', $output, $match) && version_compare($match[1], '1.7.0', '>=')) {
 $flags .= ' --ignore-ancestry';
 }
 }

 $this->io->writeError("    Checking out " . $ref);
 $this->execute($url, "svn switch" . $flags, sprintf("%s/%s", $url, $ref), $path);
 }




 public function getLocalChanges(PackageInterface $package, $path)
 {
 if (!is_dir($path.'/.svn')) {
 return;
 }

 $this->process->execute('svn status --ignore-externals', $output, $path);

 return preg_match('{^ *[^X ] +}m', $output) ? $output : null;
 }













 protected function execute($baseUrl, $command, $url, $cwd = null, $path = null)
 {
 $util = new SvnUtil($baseUrl, $this->io, $this->config);
 try {
 return $util->execute($command, $url, $cwd, $path, $this->io->isVerbose());
 } catch (\RuntimeException $e) {
 throw new \RuntimeException(
 'Package could not be downloaded, '.$e->getMessage()
 );
 }
 }




 protected function cleanChanges(PackageInterface $package, $path, $update)
 {
 if (!$changes = $this->getLocalChanges($package, $path)) {
 return;
 }

 if (!$this->io->isInteractive()) {
 if (true === $this->config->get('discard-changes')) {
 return $this->discardChanges($path);
 }

 return parent::cleanChanges($package, $path, $update);
 }

 $changes = array_map(function ($elem) {
 return '    '.$elem;
 }, preg_split('{\s*\r?\n\s*}', $changes));
 $this->io->writeError('    <error>The package has modified files:</error>');
 $this->io->writeError(array_slice($changes, 0, 10));
 if (count($changes) > 10) {
 $this->io->writeError('    <info>'.count($changes) - 10 . ' more files modified, choose "v" to view the full list</info>');
 }

 while (true) {
 switch ($this->io->ask('    <info>Discard changes [y,n,v,?]?</info> ', '?')) {
 case 'y':
 $this->discardChanges($path);
 break 2;

 case 'n':
 throw new \RuntimeException('Update aborted');

 case 'v':
 $this->io->writeError($changes);
 break;

 case '?':
 default:
 $this->io->writeError(array(
 '    y - discard changes and apply the '.($update ? 'update' : 'uninstall'),
 '    n - abort the '.($update ? 'update' : 'uninstall').' and let you manually clean things up',
 '    v - view modified files',
 '    ? - print help',
 ));
 break;
 }
 }
 }




 protected function getCommitLogs($fromReference, $toReference, $path)
 {
 if (preg_match('{.*@(\d+)$}', $fromReference) && preg_match('{.*@(\d+)$}', $toReference) ) {

 $fromRevision = preg_replace('{.*@(\d+)$}', '$1', $fromReference);
 $toRevision = preg_replace('{.*@(\d+)$}', '$1', $toReference);

 $command = sprintf('svn log -r%s:%s --incremental', $fromRevision, $toRevision);

 if (0 !== $this->process->execute($command, $output, $path)) {
 throw new \RuntimeException(
 'Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput()
 );
 }
 } else {
 $output = "Could not retrieve changes between $fromReference and $toReference due to missing revision information";
 }

 return $output;
 }

 protected function discardChanges($path)
 {
 if (0 !== $this->process->execute('svn revert -R .', $output, $path)) {
 throw new \RuntimeException("Could not reset changes\n\n:".$this->process->getErrorOutput());
 }
 }
 }
 <?php











 namespace Composer\Downloader;






 class TarDownloader extends ArchiveDownloader
 {



 protected function extract($file, $path)
 {

 $archive = new \PharData($file);
 $archive->extractTo($path, null, true);
 }
 }
 <?php











 namespace Composer\Downloader;




 class TransportException extends \RuntimeException
 {
 protected $headers;
 protected $response;

 public function setHeaders($headers)
 {
 $this->headers = $headers;
 }

 public function getHeaders()
 {
 return $this->headers;
 }

 public function setResponse($response)
 {
 $this->response = $response;
 }

 public function getResponse()
 {
 return $this->response;
 }
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Config;
 use Composer\Package\PackageInterface;
 use Composer\Util\ProcessExecutor;
 use Composer\IO\IOInterface;
 use Composer\Util\Filesystem;




 abstract class VcsDownloader implements DownloaderInterface, ChangeReportInterface
 {
 protected $io;
 protected $config;
 protected $process;
 protected $filesystem;

 public function __construct(IOInterface $io, Config $config, ProcessExecutor $process = null, Filesystem $fs = null)
 {
 $this->io = $io;
 $this->config = $config;
 $this->process = $process ?: new ProcessExecutor($io);
 $this->filesystem = $fs ?: new Filesystem;
 }




 public function getInstallationSource()
 {
 return 'source';
 }




 public function download(PackageInterface $package, $path)
 {
 if (!$package->getSourceReference()) {
 throw new \InvalidArgumentException('Package '.$package->getPrettyName().' is missing reference information');
 }

 $this->io->writeError("  - Installing <info>" . $package->getName() . "</info> (<comment>" . $package->getFullPrettyVersion() . "</comment>)");
 $this->filesystem->emptyDirectory($path);

 $urls = $package->getSourceUrls();
 while ($url = array_shift($urls)) {
 try {
 if (Filesystem::isLocalPath($url)) {
 $url = realpath($url);
 }
 $this->doDownload($package, $path, $url);
 break;
 } catch (\Exception $e) {
 if ($this->io->isDebug()) {
 $this->io->writeError('Failed: ['.get_class($e).'] '.$e->getMessage());
 } elseif (count($urls)) {
 $this->io->writeError('    Failed, trying the next URL');
 }
 if (!count($urls)) {
 throw $e;
 }
 }
 }

 $this->io->writeError('');
 }




 public function update(PackageInterface $initial, PackageInterface $target, $path)
 {
 if (!$target->getSourceReference()) {
 throw new \InvalidArgumentException('Package '.$target->getPrettyName().' is missing reference information');
 }

 $name = $target->getName();
 if ($initial->getPrettyVersion() == $target->getPrettyVersion()) {
 if ($target->getSourceType() === 'svn') {
 $from = $initial->getSourceReference();
 $to = $target->getSourceReference();
 } else {
 $from = substr($initial->getSourceReference(), 0, 7);
 $to = substr($target->getSourceReference(), 0, 7);
 }
 $name .= ' '.$initial->getPrettyVersion();
 } else {
 $from = $initial->getFullPrettyVersion();
 $to = $target->getFullPrettyVersion();
 }

 $this->io->writeError("  - Updating <info>" . $name . "</info> (<comment>" . $from . "</comment> => <comment>" . $to . "</comment>)");

 $this->cleanChanges($initial, $path, true);
 $urls = $target->getSourceUrls();
 while ($url = array_shift($urls)) {
 try {
 if (Filesystem::isLocalPath($url)) {
 $url = realpath($url);
 }
 $this->doUpdate($initial, $target, $path, $url);
 break;
 } catch (\Exception $e) {
 if ($this->io->isDebug()) {
 $this->io->writeError('Failed: ['.get_class($e).'] '.$e->getMessage());
 } elseif (count($urls)) {
 $this->io->writeError('    Failed, trying the next URL');
 } else {

 $this->reapplyChanges($path);

 throw $e;
 }
 }
 }

 $this->reapplyChanges($path);


 if ($this->io->isVerbose()) {
 $message = 'Pulling in changes:';
 $logs = $this->getCommitLogs($initial->getSourceReference(), $target->getSourceReference(), $path);

 if (!trim($logs)) {
 $message = 'Rolling back changes:';
 $logs = $this->getCommitLogs($target->getSourceReference(), $initial->getSourceReference(), $path);
 }

 if (trim($logs)) {
 $logs = implode("\n", array_map(function ($line) {
 return '      ' . $line;
 }, explode("\n", $logs)));

 $this->io->writeError('    '.$message);
 $this->io->writeError($logs);
 }
 }

 $this->io->writeError('');
 }




 public function remove(PackageInterface $package, $path)
 {
 $this->io->writeError("  - Removing <info>" . $package->getName() . "</info> (<comment>" . $package->getPrettyVersion() . "</comment>)");
 $this->cleanChanges($package, $path, false);
 if (!$this->filesystem->removeDirectory($path)) {
 throw new \RuntimeException('Could not completely delete '.$path.', aborting.');
 }
 }





 public function setOutputProgress($outputProgress)
 {
 return $this;
 }










 protected function cleanChanges(PackageInterface $package, $path, $update)
 {

 if (null !== $this->getLocalChanges($package, $path)) {
 throw new \RuntimeException('Source directory ' . $path . ' has uncommitted changes.');
 }
 }







 protected function reapplyChanges($path)
 {
 }








 abstract protected function doDownload(PackageInterface $package, $path, $url);









 abstract protected function doUpdate(PackageInterface $initial, PackageInterface $target, $path, $url);









 abstract protected function getCommitLogs($fromReference, $toReference, $path);
 }
 <?php











 namespace Composer\Downloader;

 use Composer\Config;
 use Composer\Cache;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Util\ProcessExecutor;
 use Composer\IO\IOInterface;
 use ZipArchive;




 class ZipDownloader extends ArchiveDownloader
 {
 protected $process;

 public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null, Cache $cache = null, ProcessExecutor $process = null)
 {
 $this->process = $process ?: new ProcessExecutor($io);
 parent::__construct($io, $config, $eventDispatcher, $cache);
 }

 protected function extract($file, $path)
 {
 $processError = null;


 if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
 $command = 'unzip '.ProcessExecutor::escape($file).' -d '.ProcessExecutor::escape($path) . ' && chmod -R u+w ' . ProcessExecutor::escape($path);
 try {
 if (0 === $this->process->execute($command, $ignoredOutput)) {
 return;
 }

 $processError = 'Failed to execute ' . $command . "\n\n" . $this->process->getErrorOutput();
 } catch (\Exception $e) {
 $processError = 'Failed to execute ' . $command . "\n\n" . $e->getMessage();
 }
 }

 if (!class_exists('ZipArchive')) {

 $iniPath = php_ini_loaded_file();

 if ($iniPath) {
 $iniMessage = 'The php.ini used by your command-line PHP is: ' . $iniPath;
 } else {
 $iniMessage = 'A php.ini file does not exist. You will have to create one.';
 }

 $error = "Could not decompress the archive, enable the PHP zip extension or install unzip.\n"
 . $iniMessage . "\n" . $processError;

 if (!defined('PHP_WINDOWS_VERSION_BUILD')) {
 $error = "Could not decompress the archive, enable the PHP zip extension.\n" . $iniMessage;
 }

 throw new \RuntimeException($error);
 }

 $zipArchive = new ZipArchive();

 if (true !== ($retval = $zipArchive->open($file))) {
 throw new \UnexpectedValueException($this->getErrorMessage($retval, $file), $retval);
 }

 if (true !== $zipArchive->extractTo($path)) {
 throw new \RuntimeException("There was an error extracting the ZIP file. Corrupt file?");
 }

 $zipArchive->close();
 }








 protected function getErrorMessage($retval, $file)
 {
 switch ($retval) {
 case ZipArchive::ER_EXISTS:
 return sprintf("File '%s' already exists.", $file);
 case ZipArchive::ER_INCONS:
 return sprintf("Zip archive '%s' is inconsistent.", $file);
 case ZipArchive::ER_INVAL:
 return sprintf("Invalid argument (%s)", $file);
 case ZipArchive::ER_MEMORY:
 return sprintf("Malloc failure (%s)", $file);
 case ZipArchive::ER_NOENT:
 return sprintf("No such zip file: '%s'", $file);
 case ZipArchive::ER_NOZIP:
 return sprintf("'%s' is not a zip archive.", $file);
 case ZipArchive::ER_OPEN:
 return sprintf("Can't open zip file: %s", $file);
 case ZipArchive::ER_READ:
 return sprintf("Zip read error (%s)", $file);
 case ZipArchive::ER_SEEK:
 return sprintf("Zip seek error (%s)", $file);
 default:
 return sprintf("'%s' is not a valid zip archive, got error code: %s", $file, $retval);
 }
 }
 }
 <?php











 namespace Composer\EventDispatcher;






 class Event
 {



 protected $name;




 protected $args;




 protected $flags;




 private $propagationStopped = false;








 public function __construct($name, array $args = array(), array $flags = array())
 {
 $this->name = $name;
 $this->args = $args;
 $this->flags = $flags;
 }






 public function getName()
 {
 return $this->name;
 }






 public function getArguments()
 {
 return $this->args;
 }






 public function getFlags()
 {
 return $this->flags;
 }






 public function isPropagationStopped()
 {
 return $this->propagationStopped;
 }




 public function stopPropagation()
 {
 $this->propagationStopped = true;
 }
 }
 <?php











 namespace Composer\EventDispatcher;

 use Composer\DependencyResolver\PolicyInterface;
 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\Request;
 use Composer\Installer\InstallerEvent;
 use Composer\IO\IOInterface;
 use Composer\Composer;
 use Composer\DependencyResolver\Operation\OperationInterface;
 use Composer\Repository\CompositeRepository;
 use Composer\Script;
 use Composer\Script\CommandEvent;
 use Composer\Script\PackageEvent;
 use Composer\Util\ProcessExecutor;














 class EventDispatcher
 {
 protected $composer;
 protected $io;
 protected $loader;
 protected $process;
 protected $listeners;








 public function __construct(Composer $composer, IOInterface $io, ProcessExecutor $process = null)
 {
 $this->composer = $composer;
 $this->io = $io;
 $this->process = $process ?: new ProcessExecutor($io);
 }









 public function dispatch($eventName, Event $event = null)
 {
 if (null == $event) {
 $event = new Event($eventName);
 }

 return $this->doDispatch($event);
 }











 public function dispatchScript($eventName, $devMode = false, $additionalArgs = array(), $flags = array())
 {
 return $this->doDispatch(new Script\Event($eventName, $this->composer, $this->io, $devMode, $additionalArgs, $flags));
 }
















 public function dispatchPackageEvent($eventName, $devMode, PolicyInterface $policy, Pool $pool, CompositeRepository $installedRepo, Request $request, array $operations, OperationInterface $operation)
 {
 return $this->doDispatch(new PackageEvent($eventName, $this->composer, $this->io, $devMode, $policy, $pool, $installedRepo, $request, $operations, $operation));
 }















 public function dispatchInstallerEvent($eventName, $devMode, PolicyInterface $policy, Pool $pool, CompositeRepository $installedRepo, Request $request, array $operations = array())
 {
 return $this->doDispatch(new InstallerEvent($eventName, $this->composer, $this->io, $devMode, $policy, $pool, $installedRepo, $request, $operations));
 }











 protected function doDispatch(Event $event)
 {
 $listeners = $this->getListeners($event);

 $return = 0;
 foreach ($listeners as $callable) {
 if (!is_string($callable) && is_callable($callable)) {
 $event = $this->checkListenerExpectedEvent($callable, $event);
 $return = false === call_user_func($callable, $event) ? 1 : 0;
 } elseif ($this->isPhpScript($callable)) {
 $className = substr($callable, 0, strpos($callable, '::'));
 $methodName = substr($callable, strpos($callable, '::') + 2);

 if (!class_exists($className)) {
 $this->io->writeError('<warning>Class '.$className.' is not autoloadable, can not call '.$event->getName().' script</warning>');
 continue;
 }
 if (!is_callable($callable)) {
 $this->io->writeError('<warning>Method '.$callable.' is not callable, can not call '.$event->getName().' script</warning>');
 continue;
 }

 try {
 $return = false === $this->executeEventPhpScript($className, $methodName, $event) ? 1 : 0;
 } catch (\Exception $e) {
 $message = "Script %s handling the %s event terminated with an exception";
 $this->io->writeError('<error>'.sprintf($message, $callable, $event->getName()).'</error>');
 throw $e;
 }
 } else {
 $args = implode(' ', array_map(array('Composer\Util\ProcessExecutor', 'escape'), $event->getArguments()));
 $exec = $callable . ($args === '' ? '' : ' '.$args);
 if ($this->io->isVerbose()) {
 $this->io->writeError(sprintf('> %s: %s', $event->getName(), $exec));
 } else {
 $this->io->writeError(sprintf('> %s', $exec));
 }
 if (0 !== ($exitCode = $this->process->execute($exec))) {
 $this->io->writeError(sprintf('<error>Script %s handling the %s event returned with an error</error>', $callable, $event->getName()));

 throw new \RuntimeException('Error Output: '.$this->process->getErrorOutput(), $exitCode);
 }
 }

 if ($event->isPropagationStopped()) {
 break;
 }
 }

 return $return;
 }






 protected function executeEventPhpScript($className, $methodName, Event $event)
 {
 $event = $this->checkListenerExpectedEvent(array($className, $methodName), $event);

 if ($this->io->isVerbose()) {
 $this->io->writeError(sprintf('> %s: %s::%s', $event->getName(), $className, $methodName));
 } else {
 $this->io->writeError(sprintf('> %s::%s', $className, $methodName));
 }

 return $className::$methodName($event);
 }






 protected function checkListenerExpectedEvent($target, Event $event)
 {
 try {
 $reflected = new \ReflectionParameter($target, 0);
 } catch (\Exception $e) {
 return $event;
 }

 $typehint = $reflected->getClass();

 if (!$typehint instanceof \ReflectionClass) {
 return $event;
 }

 $expected = $typehint->getName();


 if (!$event instanceof $expected && $expected === 'Composer\Script\CommandEvent') {
 $event = new \Composer\Script\CommandEvent(
 $event->getName(), $event->getComposer(), $event->getIO(), $event->isDevMode(), $event->getArguments()
 );
 }
 if (!$event instanceof $expected && $expected === 'Composer\Script\PackageEvent') {
 $event = new \Composer\Script\PackageEvent(
 $event->getName(), $event->getComposer(), $event->getIO(), $event->isDevMode(),
 $event->getPolicy(), $event->getPool(), $event->getInstalledRepo(), $event->getRequest(),
 $event->getOperations(), $event->getOperation()
 );
 }
 if (!$event instanceof $expected && $expected === 'Composer\Script\Event') {
 $event = new \Composer\Script\Event(
 $event->getName(), $event->getComposer(), $event->getIO(), $event->isDevMode(),
 $event->getArguments(), $event->getFlags()
 );
 }

 return $event;
 }








 protected function addListener($eventName, $listener, $priority = 0)
 {
 $this->listeners[$eventName][$priority][] = $listener;
 }








 public function addSubscriber(EventSubscriberInterface $subscriber)
 {
 foreach ($subscriber->getSubscribedEvents() as $eventName => $params) {
 if (is_string($params)) {
 $this->addListener($eventName, array($subscriber, $params));
 } elseif (is_string($params[0])) {
 $this->addListener($eventName, array($subscriber, $params[0]), isset($params[1]) ? $params[1] : 0);
 } else {
 foreach ($params as $listener) {
 $this->addListener($eventName, array($subscriber, $listener[0]), isset($listener[1]) ? $listener[1] : 0);
 }
 }
 }
 }







 protected function getListeners(Event $event)
 {
 $scriptListeners = $this->getScriptListeners($event);

 if (!isset($this->listeners[$event->getName()][0])) {
 $this->listeners[$event->getName()][0] = array();
 }
 krsort($this->listeners[$event->getName()]);

 $listeners = $this->listeners;
 $listeners[$event->getName()][0] = array_merge($listeners[$event->getName()][0], $scriptListeners);

 return call_user_func_array('array_merge', $listeners[$event->getName()]);
 }







 public function hasEventListeners(Event $event)
 {
 $listeners = $this->getListeners($event);

 return count($listeners) > 0;
 }







 protected function getScriptListeners(Event $event)
 {
 $package = $this->composer->getPackage();
 $scripts = $package->getScripts();

 if (empty($scripts[$event->getName()])) {
 return array();
 }

 if ($this->loader) {
 $this->loader->unregister();
 }

 $generator = $this->composer->getAutoloadGenerator();
 $packages = $this->composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
 $packageMap = $generator->buildPackageMap($this->composer->getInstallationManager(), $package, $packages);
 $map = $generator->parseAutoloads($packageMap, $package);
 $this->loader = $generator->createLoader($map);
 $this->loader->register();

 return $scripts[$event->getName()];
 }







 protected function isPhpScript($callable)
 {
 return false === strpos($callable, ' ') && false !== strpos($callable, '::');
 }
 }
 <?php











 namespace Composer\EventDispatcher;













 interface EventSubscriberInterface
 {


















 public static function getSubscribedEvents();
 }
 <?php











 namespace Composer;

 use Composer\Config\JsonConfigSource;
 use Composer\Json\JsonFile;
 use Composer\IO\IOInterface;
 use Composer\Package\Archiver;
 use Composer\Repository\RepositoryManager;
 use Composer\Repository\WritableRepositoryInterface;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\RemoteFilesystem;
 use Symfony\Component\Console\Formatter\OutputFormatterStyle;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Autoload\AutoloadGenerator;
 use Composer\Package\Version\VersionParser;









 class Factory
 {




 protected static function getHomeDir()
 {
 $home = getenv('COMPOSER_HOME');
 if (!$home) {
 if (defined('PHP_WINDOWS_VERSION_MAJOR')) {
 if (!getenv('APPDATA')) {
 throw new \RuntimeException('The APPDATA or COMPOSER_HOME environment variable must be set for composer to run correctly');
 }
 $home = strtr(getenv('APPDATA'), '\\', '/') . '/Composer';
 } else {
 if (!getenv('HOME')) {
 throw new \RuntimeException('The HOME or COMPOSER_HOME environment variable must be set for composer to run correctly');
 }
 $home = rtrim(getenv('HOME'), '/') . '/.composer';
 }
 }

 return $home;
 }






 protected static function getCacheDir($home)
 {
 $cacheDir = getenv('COMPOSER_CACHE_DIR');
 if (!$cacheDir) {
 if (defined('PHP_WINDOWS_VERSION_MAJOR')) {
 if ($cacheDir = getenv('LOCALAPPDATA')) {
 $cacheDir .= '/Composer';
 } else {
 $cacheDir = $home . '/cache';
 }
 $cacheDir = strtr($cacheDir, '\\', '/');
 } else {
 $cacheDir = $home.'/cache';
 }
 }

 return $cacheDir;
 }





 public static function createConfig(IOInterface $io = null, $cwd = null)
 {
 $cwd = $cwd ?: getcwd();


 $home = self::getHomeDir();
 $cacheDir = self::getCacheDir($home);


 
 
 foreach (array($home, $cacheDir) as $dir) {
 if (!file_exists($dir . '/.htaccess')) {
 if (!is_dir($dir)) {
 @mkdir($dir, 0777, true);
 }
 @file_put_contents($dir . '/.htaccess', 'Deny from all');
 }
 }

 $config = new Config(true, $cwd);


 $config->merge(array('config' => array('home' => $home, 'cache-dir' => $cacheDir)));


 $file = new JsonFile($config->get('home').'/config.json');
 if ($file->exists()) {
 if ($io && $io->isDebug()) {
 $io->writeError('Loading config file ' . $file->getPath());
 }
 $config->merge($file->read());
 }
 $config->setConfigSource(new JsonConfigSource($file));


 $file = new JsonFile($config->get('home').'/auth.json');
 if ($file->exists()) {
 if ($io && $io->isDebug()) {
 $io->writeError('Loading config file ' . $file->getPath());
 }
 $config->merge(array('config' => $file->read()));
 }
 $config->setAuthConfigSource(new JsonConfigSource($file, true));

 return $config;
 }

 public static function getComposerFile()
 {
 return trim(getenv('COMPOSER')) ?: './composer.json';
 }

 public static function createAdditionalStyles()
 {
 return array(
 'highlight' => new OutputFormatterStyle('red'),
 'warning' => new OutputFormatterStyle('black', 'yellow'),
 );
 }

 public static function createDefaultRepositories(IOInterface $io = null, Config $config = null, RepositoryManager $rm = null)
 {
 $repos = array();

 if (!$config) {
 $config = static::createConfig($io);
 }
 if (!$rm) {
 if (!$io) {
 throw new \InvalidArgumentException('This function requires either an IOInterface or a RepositoryManager');
 }
 $factory = new static;
 $rm = $factory->createRepositoryManager($io, $config);
 }

 foreach ($config->getRepositories() as $index => $repo) {
 if (is_string($repo)) {
 throw new \UnexpectedValueException('"repositories" should be an array of repository definitions, only a single repository was given');
 }
 if (!is_array($repo)) {
 throw new \UnexpectedValueException('Repository "'.$index.'" ('.json_encode($repo).') should be an array, '.gettype($repo).' given');
 }
 if (!isset($repo['type'])) {
 throw new \UnexpectedValueException('Repository "'.$index.'" ('.json_encode($repo).') must have a type defined');
 }
 $name = is_int($index) && isset($repo['url']) ? preg_replace('{^https?://}i', '', $repo['url']) : $index;
 while (isset($repos[$name])) {
 $name .= '2';
 }
 $repos[$name] = $rm->createRepository($repo['type'], $repo);
 }

 return $repos;
 }













 public function createComposer(IOInterface $io, $localConfig = null, $disablePlugins = false, $cwd = null, $fullLoad = true)
 {
 $cwd = $cwd ?: getcwd();


 if (null === $localConfig) {
 $localConfig = static::getComposerFile();
 }

 if (is_string($localConfig)) {
 $composerFile = $localConfig;
 $file = new JsonFile($localConfig, new RemoteFilesystem($io));

 if (!$file->exists()) {
 if ($localConfig === './composer.json' || $localConfig === 'composer.json') {
 $message = 'Composer could not find a composer.json file in '.$cwd;
 } else {
 $message = 'Composer could not find the config file: '.$localConfig;
 }
 $instructions = 'To initialize a project, please create a composer.json file as described in the https://getcomposer.org/ "Getting Started" section';
 throw new \InvalidArgumentException($message.PHP_EOL.$instructions);
 }

 $file->validateSchema(JsonFile::LAX_SCHEMA);
 $localConfig = $file->read();
 }


 $config = static::createConfig($io, $cwd);
 $config->merge($localConfig);
 if (isset($composerFile)) {
 if ($io && $io->isDebug()) {
 $io->writeError('Loading config file ' . $composerFile);
 }
 $localAuthFile = new JsonFile(dirname(realpath($composerFile)) . '/auth.json');
 if ($localAuthFile->exists()) {
 if ($io && $io->isDebug()) {
 $io->writeError('Loading config file ' . $localAuthFile->getPath());
 }
 $config->merge(array('config' => $localAuthFile->read()));
 $config->setAuthConfigSource(new JsonConfigSource($localAuthFile, true));
 }
 }

 $vendorDir = $config->get('vendor-dir');
 $binDir = $config->get('bin-dir');


 $composer = new Composer();
 $composer->setConfig($config);

 if ($fullLoad) {

 $io->loadConfiguration($config);
 }


 $dispatcher = new EventDispatcher($composer, $io);
 $composer->setEventDispatcher($dispatcher);


 $rm = $this->createRepositoryManager($io, $config, $dispatcher);
 $composer->setRepositoryManager($rm);


 $this->addLocalRepository($rm, $vendorDir);


 $parser = new VersionParser;
 $loader = new Package\Loader\RootPackageLoader($rm, $config, $parser, new ProcessExecutor($io));
 $package = $loader->load($localConfig);
 $composer->setPackage($package);


 $im = $this->createInstallationManager();
 $composer->setInstallationManager($im);

 if ($fullLoad) {

 $dm = $this->createDownloadManager($io, $config, $dispatcher);
 $composer->setDownloadManager($dm);


 $generator = new AutoloadGenerator($dispatcher, $io);
 $composer->setAutoloadGenerator($generator);
 }


 $this->createDefaultInstallers($im, $composer, $io);

 if ($fullLoad) {
 $globalComposer = $this->createGlobalComposer($io, $config, $disablePlugins);
 $pm = $this->createPluginManager($io, $composer, $globalComposer);
 $composer->setPluginManager($pm);

 if (!$disablePlugins) {
 $pm->loadInstalledPlugins();
 }


 
 if ($rm->getLocalRepository()) {
 $this->purgePackages($rm->getLocalRepository(), $im);
 }
 }


 if ($fullLoad && isset($composerFile)) {
 $lockFile = "json" === pathinfo($composerFile, PATHINFO_EXTENSION)
 ? substr($composerFile, 0, -4).'lock'
 : $composerFile . '.lock';
 $locker = new Package\Locker($io, new JsonFile($lockFile, new RemoteFilesystem($io, $config)), $rm, $im, md5_file($composerFile));
 $composer->setLocker($locker);
 }

 return $composer;
 }







 protected function createRepositoryManager(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null)
 {
 $rm = new RepositoryManager($io, $config, $eventDispatcher);
 $rm->setRepositoryClass('composer', 'Composer\Repository\ComposerRepository');
 $rm->setRepositoryClass('vcs', 'Composer\Repository\VcsRepository');
 $rm->setRepositoryClass('package', 'Composer\Repository\PackageRepository');
 $rm->setRepositoryClass('pear', 'Composer\Repository\PearRepository');
 $rm->setRepositoryClass('git', 'Composer\Repository\VcsRepository');
 $rm->setRepositoryClass('svn', 'Composer\Repository\VcsRepository');
 $rm->setRepositoryClass('perforce', 'Composer\Repository\VcsRepository');
 $rm->setRepositoryClass('hg', 'Composer\Repository\VcsRepository');
 $rm->setRepositoryClass('artifact', 'Composer\Repository\ArtifactRepository');

 return $rm;
 }





 protected function addLocalRepository(RepositoryManager $rm, $vendorDir)
 {
 $rm->setLocalRepository(new Repository\InstalledFilesystemRepository(new JsonFile($vendorDir.'/composer/installed.json')));
 }





 protected function createGlobalComposer(IOInterface $io, Config $config, $disablePlugins)
 {
 if (realpath($config->get('home')) === getcwd()) {
 return;
 }

 $composer = null;
 try {
 $composer = self::createComposer($io, $config->get('home') . '/composer.json', $disablePlugins, $config->get('home'), false);
 } catch (\Exception $e) {
 if ($io->isDebug()) {
 $io->writeError('Failed to initialize global composer: '.$e->getMessage());
 }
 }

 return $composer;
 }







 public function createDownloadManager(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null)
 {
 $cache = null;
 if ($config->get('cache-files-ttl') > 0) {
 $cache = new Cache($io, $config->get('cache-files-dir'), 'a-z0-9_./');
 }

 $dm = new Downloader\DownloadManager($io);
 switch ($config->get('preferred-install')) {
 case 'dist':
 $dm->setPreferDist(true);
 break;
 case 'source':
 $dm->setPreferSource(true);
 break;
 case 'auto':
 default:

 break;
 }

 $dm->setDownloader('git', new Downloader\GitDownloader($io, $config));
 $dm->setDownloader('svn', new Downloader\SvnDownloader($io, $config));
 $dm->setDownloader('hg', new Downloader\HgDownloader($io, $config));
 $dm->setDownloader('perforce', new Downloader\PerforceDownloader($io, $config));
 $dm->setDownloader('zip', new Downloader\ZipDownloader($io, $config, $eventDispatcher, $cache));
 $dm->setDownloader('rar', new Downloader\RarDownloader($io, $config, $eventDispatcher, $cache));
 $dm->setDownloader('tar', new Downloader\TarDownloader($io, $config, $eventDispatcher, $cache));
 $dm->setDownloader('gzip', new Downloader\GzipDownloader($io, $config, $eventDispatcher, $cache));
 $dm->setDownloader('phar', new Downloader\PharDownloader($io, $config, $eventDispatcher, $cache));
 $dm->setDownloader('file', new Downloader\FileDownloader($io, $config, $eventDispatcher, $cache));

 return $dm;
 }







 public function createArchiveManager(Config $config, Downloader\DownloadManager $dm = null)
 {
 if (null === $dm) {
 $io = new IO\NullIO();
 $io->loadConfiguration($config);
 $dm = $this->createDownloadManager($io, $config);
 }

 $am = new Archiver\ArchiveManager($dm);
 $am->addArchiver(new Archiver\PharArchiver);

 return $am;
 }







 protected function createPluginManager(IOInterface $io, Composer $composer, Composer $globalComposer = null)
 {
 return new Plugin\PluginManager($io, $composer, $globalComposer);
 }




 protected function createInstallationManager()
 {
 return new Installer\InstallationManager();
 }






 protected function createDefaultInstallers(Installer\InstallationManager $im, Composer $composer, IOInterface $io)
 {
 $im->addInstaller(new Installer\LibraryInstaller($io, $composer, null));
 $im->addInstaller(new Installer\PearInstaller($io, $composer, 'pear-library'));
 $im->addInstaller(new Installer\PluginInstaller($io, $composer));
 $im->addInstaller(new Installer\MetapackageInstaller($io));
 }





 protected function purgePackages(WritableRepositoryInterface $repo, Installer\InstallationManager $im)
 {
 foreach ($repo->getPackages() as $package) {
 if (!$im->isPackageInstalled($repo, $package)) {
 $repo->removePackage($package);
 }
 }
 }








 public static function create(IOInterface $io, $config = null, $disablePlugins = false)
 {
 $factory = new static();

 return $factory->createComposer($io, $config, $disablePlugins);
 }
 }
 <?php











 namespace Composer\IO;

 use Composer\Config;
 use Composer\Util\ProcessExecutor;

 abstract class BaseIO implements IOInterface
 {
 protected $authentications = array();




 public function getAuthentications()
 {
 return $this->authentications;
 }




 public function hasAuthentication($repositoryName)
 {
 return isset($this->authentications[$repositoryName]);
 }




 public function getAuthentication($repositoryName)
 {
 if (isset($this->authentications[$repositoryName])) {
 return $this->authentications[$repositoryName];
 }

 return array('username' => null, 'password' => null);
 }




 public function setAuthentication($repositoryName, $username, $password = null)
 {
 $this->authentications[$repositoryName] = array('username' => $username, 'password' => $password);
 }




 public function loadConfiguration(Config $config)
 {

 if ($tokens = $config->get('github-oauth')) {
 foreach ($tokens as $domain => $token) {
 if (!preg_match('{^[a-z0-9]+$}', $token)) {
 throw new \UnexpectedValueException('Your github oauth token for '.$domain.' contains invalid characters: "'.$token.'"');
 }
 $this->setAuthentication($domain, $token, 'x-oauth-basic');
 }
 }


 if ($creds = $config->get('http-basic')) {
 foreach ($creds as $domain => $cred) {
 $this->setAuthentication($domain, $cred['username'], $cred['password']);
 }
 }


 ProcessExecutor::setTimeout((int) $config->get('process-timeout'));
 }
 }
 <?php











 namespace Composer\IO;

 use Symfony\Component\Console\Output\StreamOutput;
 use Symfony\Component\Console\Formatter\OutputFormatterInterface;
 use Symfony\Component\Console\Input\StringInput;
 use Symfony\Component\Console\Helper\HelperSet;




 class BufferIO extends ConsoleIO
 {





 public function __construct(
 $input = '',
 $verbosity = StreamOutput::VERBOSITY_NORMAL,
 OutputFormatterInterface $formatter = null
 ) {
 $input = new StringInput($input);
 $input->setInteractive(false);

 $output = new StreamOutput(fopen('php://memory', 'rw'), $verbosity, !empty($formatter), $formatter);

 parent::__construct($input, $output, new HelperSet(array()));
 }

 public function getOutput()
 {
 fseek($this->output->getStream(), 0);

 $output = stream_get_contents($this->output->getStream());

 $output = preg_replace_callback("{(?<=^|\n|\x08)(.+?)(\x08+)}", function ($matches) {
 $pre = strip_tags($matches[1]);

 if (strlen($pre) === strlen($matches[2])) {
 return '';
 }


 return rtrim($matches[1])."\n";
 }, $output);

 return $output;
 }
 }
 <?php











 namespace Composer\IO;

 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\ConsoleOutputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Helper\HelperSet;
 use Symfony\Component\Console\Question\ConfirmationQuestion;
 use Symfony\Component\Console\Question\Question;







 class ConsoleIO extends BaseIO
 {
 protected $input;
 protected $output;
 protected $helperSet;
 protected $lastMessage;
 protected $lastMessageErr;
 private $startTime;








 public function __construct(InputInterface $input, OutputInterface $output, HelperSet $helperSet)
 {
 $this->input = $input;
 $this->output = $output;
 $this->helperSet = $helperSet;
 }

 public function enableDebugging($startTime)
 {
 $this->startTime = $startTime;
 }




 public function isInteractive()
 {
 return $this->input->isInteractive();
 }




 public function isDecorated()
 {
 return $this->output->isDecorated();
 }




 public function isVerbose()
 {
 return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE;
 }




 public function isVeryVerbose()
 {
 return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE;
 }




 public function isDebug()
 {
 return $this->output->getVerbosity() >= OutputInterface::VERBOSITY_DEBUG;
 }




 public function write($messages, $newline = true)
 {
 $this->doWrite($messages, $newline, false);
 }




 public function writeError($messages, $newline = true)
 {
 $this->doWrite($messages, $newline, true);
 }






 private function doWrite($messages, $newline, $stderr)
 {
 if (null !== $this->startTime) {
 $memoryUsage = memory_get_usage() / 1024 / 1024;
 $timeSpent = microtime(true) - $this->startTime;
 $messages = array_map(function ($message) use ($memoryUsage, $timeSpent) {
 return sprintf('[%.1fMB/%.2fs] %s', $memoryUsage, $timeSpent, $message);
 }, (array) $messages);
 }

 if (true === $stderr && $this->output instanceof ConsoleOutputInterface) {
 $this->output->getErrorOutput()->write($messages, $newline);
 $this->lastMessageErr = join($newline ? "\n" : '', (array) $messages);

 return;
 }

 $this->output->write($messages, $newline);
 $this->lastMessage = join($newline ? "\n" : '', (array) $messages);
 }




 public function overwrite($messages, $newline = true, $size = null)
 {
 $this->doOverwrite($messages, $newline, $size, false);
 }




 public function overwriteError($messages, $newline = true, $size = null)
 {
 $this->doOverwrite($messages, $newline, $size, true);
 }







 private function doOverwrite($messages, $newline, $size, $stderr)
 {

 $messages = join($newline ? "\n" : '', (array) $messages);


 if (!isset($size)) {

 $size = strlen(strip_tags($stderr ? $this->lastMessageErr : $this->lastMessage));
 }

 $this->doWrite(str_repeat("\x08", $size), false, $stderr);


 $this->doWrite($messages, false, $stderr);

 $fill = $size - strlen(strip_tags($messages));
 if ($fill > 0) {

 $this->doWrite(str_repeat(' ', $fill), false, $stderr);

 $this->doWrite(str_repeat("\x08", $fill), false, $stderr);
 }

 if ($newline) {
 $this->doWrite('', true, $stderr);
 }

 if ($stderr) {
 $this->lastMessageErr = $messages;
 } else {
 $this->lastMessage = $messages;
 }
 }




 public function ask($question, $default = null)
 {
 $output = $this->output;

 if ($output instanceof ConsoleOutputInterface) {
 $output = $output->getErrorOutput();
 }


 $helper = $this->helperSet->get('question');
 $question = new Question($question, $default);

 return $helper->ask($this->input, $output, $question);
 }




 public function askConfirmation($question, $default = true)
 {
 $output = $this->output;

 if ($output instanceof ConsoleOutputInterface) {
 $output = $output->getErrorOutput();
 }


 $helper = $this->helperSet->get('question');
 $question = new ConfirmationQuestion($question, $default);

 return $helper->ask($this->input, $output, $question);
 }




 public function askAndValidate($question, $validator, $attempts = null, $default = null)
 {
 $output = $this->output;

 if ($output instanceof ConsoleOutputInterface) {
 $output = $output->getErrorOutput();
 }


 $helper = $this->helperSet->get('question');
 $question = new Question($question, $default);
 $question->setValidator($validator);
 $question->setMaxAttempts($attempts);

 return $helper->ask($this->input, $output, $question);
 }




 public function askAndHideAnswer($question)
 {
 $this->writeError($question, false);

 return \Seld\CliPrompt\CliPrompt::hiddenPrompt(true);
 }
 }
 <?php











 namespace Composer\IO;

 use Composer\Config;






 interface IOInterface
 {





 public function isInteractive();






 public function isVerbose();






 public function isVeryVerbose();






 public function isDebug();






 public function isDecorated();







 public function write($messages, $newline = true);







 public function writeError($messages, $newline = true);








 public function overwrite($messages, $newline = true, $size = null);








 public function overwriteError($messages, $newline = true, $size = null);











 public function ask($question, $default = null);











 public function askConfirmation($question, $default = true);

















 public function askAndValidate($question, $validator, $attempts = null, $default = null);








 public function askAndHideAnswer($question);






 public function getAuthentications();








 public function hasAuthentication($repositoryName);








 public function getAuthentication($repositoryName);








 public function setAuthentication($repositoryName, $username, $password = null);






 public function loadConfiguration(Config $config);
 }
 <?php











 namespace Composer\IO;






 class NullIO extends BaseIO
 {



 public function isInteractive()
 {
 return false;
 }




 public function isVerbose()
 {
 return false;
 }




 public function isVeryVerbose()
 {
 return false;
 }




 public function isDebug()
 {
 return false;
 }




 public function isDecorated()
 {
 return false;
 }




 public function write($messages, $newline = true)
 {
 }




 public function writeError($messages, $newline = true)
 {
 }




 public function overwrite($messages, $newline = true, $size = 80)
 {
 }




 public function overwriteError($messages, $newline = true, $size = 80)
 {
 }




 public function ask($question, $default = null)
 {
 return $default;
 }




 public function askConfirmation($question, $default = true)
 {
 return $default;
 }




 public function askAndValidate($question, $validator, $attempts = false, $default = null)
 {
 return $default;
 }




 public function askAndHideAnswer($question)
 {
 return null;
 }
 }
 <?php











 namespace Composer;

 use Composer\Autoload\AutoloadGenerator;
 use Composer\DependencyResolver\DefaultPolicy;
 use Composer\DependencyResolver\Operation\UpdateOperation;
 use Composer\DependencyResolver\Operation\InstallOperation;
 use Composer\DependencyResolver\Operation\UninstallOperation;
 use Composer\DependencyResolver\Operation\OperationInterface;
 use Composer\DependencyResolver\PolicyInterface;
 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\Request;
 use Composer\DependencyResolver\Rule;
 use Composer\DependencyResolver\Solver;
 use Composer\DependencyResolver\SolverProblemsException;
 use Composer\Downloader\DownloadManager;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Installer\InstallationManager;
 use Composer\Installer\InstallerEvents;
 use Composer\Installer\NoopInstaller;
 use Composer\IO\IOInterface;
 use Composer\Json\JsonFile;
 use Composer\Package\AliasPackage;
 use Composer\Package\CompletePackage;
 use Composer\Package\Link;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Package\Locker;
 use Composer\Package\PackageInterface;
 use Composer\Package\RootPackageInterface;
 use Composer\Repository\CompositeRepository;
 use Composer\Repository\InstalledArrayRepository;
 use Composer\Repository\InstalledFilesystemRepository;
 use Composer\Repository\PlatformRepository;
 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\RepositoryManager;
 use Composer\Repository\WritableRepositoryInterface;
 use Composer\Script\ScriptEvents;







 class Installer
 {



 protected $io;




 protected $config;




 protected $package;




 protected $downloadManager;




 protected $repositoryManager;




 protected $locker;




 protected $installationManager;




 protected $eventDispatcher;




 protected $autoloadGenerator;

 protected $preferSource = false;
 protected $preferDist = false;
 protected $optimizeAutoloader = false;
 protected $devMode = false;
 protected $dryRun = false;
 protected $verbose = false;
 protected $update = false;
 protected $dumpAutoloader = true;
 protected $runScripts = true;
 protected $ignorePlatformReqs = false;
 protected $preferStable = false;
 protected $preferLowest = false;





 protected $updateWhitelist = null;
 protected $whitelistDependencies = false;




 protected $suggestedPackages;




 protected $additionalInstalledRepository;














 public function __construct(IOInterface $io, Config $config, RootPackageInterface $package, DownloadManager $downloadManager, RepositoryManager $repositoryManager, Locker $locker, InstallationManager $installationManager, EventDispatcher $eventDispatcher, AutoloadGenerator $autoloadGenerator)
 {
 $this->io = $io;
 $this->config = $config;
 $this->package = $package;
 $this->downloadManager = $downloadManager;
 $this->repositoryManager = $repositoryManager;
 $this->locker = $locker;
 $this->installationManager = $installationManager;
 $this->eventDispatcher = $eventDispatcher;
 $this->autoloadGenerator = $autoloadGenerator;
 }








 public function run()
 {
 gc_collect_cycles();
 gc_disable();

 if ($this->dryRun) {
 $this->verbose = true;
 $this->runScripts = false;
 $this->installationManager->addInstaller(new NoopInstaller);
 $this->mockLocalRepositories($this->repositoryManager);
 }


 
 $devRepo = new InstalledFilesystemRepository(new JsonFile($this->config->get('vendor-dir').'/composer/installed_dev.json'));
 if ($devRepo->getPackages()) {
 $this->io->writeError('<warning>BC Notice: Removing old dev packages to migrate to the new require-dev handling.</warning>');
 foreach ($devRepo->getPackages() as $package) {
 if ($this->installationManager->isPackageInstalled($devRepo, $package)) {
 $this->installationManager->uninstall($devRepo, new UninstallOperation($package));
 }
 }
 unlink($this->config->get('vendor-dir').'/composer/installed_dev.json');
 }
 unset($devRepo, $package);


 if ($this->runScripts) {

 $eventName = $this->update ? ScriptEvents::PRE_UPDATE_CMD : ScriptEvents::PRE_INSTALL_CMD;
 $this->eventDispatcher->dispatchScript($eventName, $this->devMode);
 }

 $this->downloadManager->setPreferSource($this->preferSource);
 $this->downloadManager->setPreferDist($this->preferDist);


 
 
 $installedRootPackage = clone $this->package;
 $installedRootPackage->setRequires(array());
 $installedRootPackage->setDevRequires(array());


 $localRepo = $this->repositoryManager->getLocalRepository();
 if (!$this->update && $this->locker->isLocked()) {
 $platformOverrides = $this->locker->getPlatformOverrides();
 } else {
 $platformOverrides = $this->config->get('platform') ?: array();
 }
 $platformRepo = new PlatformRepository(array(), $platformOverrides);
 $repos = array(
 $localRepo,
 new InstalledArrayRepository(array($installedRootPackage)),
 $platformRepo,
 );
 $installedRepo = new CompositeRepository($repos);
 if ($this->additionalInstalledRepository) {
 $installedRepo->addRepository($this->additionalInstalledRepository);
 }

 $aliases = $this->getRootAliases();
 $this->aliasPlatformPackages($platformRepo, $aliases);

 try {
 $this->suggestedPackages = array();
 $res = $this->doInstall($localRepo, $installedRepo, $platformRepo, $aliases, $this->devMode);
 if ($res !== 0) {
 return $res;
 }
 } catch (\Exception $e) {
 $this->installationManager->notifyInstalls();

 throw $e;
 }
 $this->installationManager->notifyInstalls();


 if ($this->devMode) {
 foreach ($this->suggestedPackages as $suggestion) {
 $target = $suggestion['target'];
 foreach ($installedRepo->getPackages() as $package) {
 if (in_array($target, $package->getNames())) {
 continue 2;
 }
 }

 $this->io->writeError($suggestion['source'].' suggests installing '.$suggestion['target'].' ('.$suggestion['reason'].')');
 }
 }


 foreach ($localRepo->getPackages() as $package) {
 if (!$package instanceof CompletePackage || !$package->isAbandoned()) {
 continue;
 }

 $replacement = (is_string($package->getReplacementPackage()))
 ? 'Use ' . $package->getReplacementPackage() . ' instead'
 : 'No replacement was suggested';

 $this->io->writeError(
 sprintf(
 "<warning>Package %s is abandoned, you should avoid using it. %s.</warning>",
 $package->getPrettyName(),
 $replacement
 )
 );
 }

 if (!$this->dryRun) {

 if ($this->update || !$this->locker->isLocked()) {
 $localRepo->reload();


 
 $devPackages = ($this->devMode || !$this->package->getDevRequires()) ? array() : null;


 if ($this->devMode && $this->package->getDevRequires()) {
 $policy = $this->createPolicy();
 $pool = $this->createPool(true);
 $pool->addRepository($installedRepo, $aliases);


 $request = $this->createRequest($this->package, $platformRepo);
 $request->updateAll();
 foreach ($this->package->getRequires() as $link) {
 $request->install($link->getTarget(), $link->getConstraint());
 }

 $this->eventDispatcher->dispatchInstallerEvent(InstallerEvents::PRE_DEPENDENCIES_SOLVING, false, $policy, $pool, $installedRepo, $request);
 $solver = new Solver($policy, $pool, $installedRepo);
 $ops = $solver->solve($request, $this->ignorePlatformReqs);
 $this->eventDispatcher->dispatchInstallerEvent(InstallerEvents::POST_DEPENDENCIES_SOLVING, false, $policy, $pool, $installedRepo, $request, $ops);
 foreach ($ops as $op) {
 if ($op->getJobType() === 'uninstall') {
 $devPackages[] = $op->getPackage();
 }
 }
 }

 $platformReqs = $this->extractPlatformRequirements($this->package->getRequires());
 $platformDevReqs = $this->devMode ? $this->extractPlatformRequirements($this->package->getDevRequires()) : array();

 $updatedLock = $this->locker->setLockData(
 array_diff($localRepo->getCanonicalPackages(), (array) $devPackages),
 $devPackages,
 $platformReqs,
 $platformDevReqs,
 $aliases,
 $this->package->getMinimumStability(),
 $this->package->getStabilityFlags(),
 $this->preferStable || $this->package->getPreferStable(),
 $this->preferLowest,
 $this->config->get('platform') ?: array()
 );
 if ($updatedLock) {
 $this->io->writeError('<info>Writing lock file</info>');
 }
 }

 if ($this->dumpAutoloader) {

 if ($this->optimizeAutoloader) {
 $this->io->writeError('<info>Generating optimized autoload files</info>');
 } else {
 $this->io->writeError('<info>Generating autoload files</info>');
 }

 $this->autoloadGenerator->setDevMode($this->devMode);
 $this->autoloadGenerator->dump($this->config, $localRepo, $this->package, $this->installationManager, 'composer', $this->optimizeAutoloader);
 }

 if ($this->runScripts) {

 $eventName = $this->update ? ScriptEvents::POST_UPDATE_CMD : ScriptEvents::POST_INSTALL_CMD;
 $this->eventDispatcher->dispatchScript($eventName, $this->devMode);
 }

 $vendorDir = $this->config->get('vendor-dir');
 if (is_dir($vendorDir)) {

 
 @touch($vendorDir);
 }
 }

 return 0;
 }









 protected function doInstall($localRepo, $installedRepo, $platformRepo, $aliases, $withDevReqs)
 {

 $lockedRepository = null;
 $repositories = null;


 $installFromLock = !$this->update && $this->locker->isLocked();


 
 
 if ($installFromLock || (!empty($this->updateWhitelist) && $this->locker->isLocked())) {
 try {
 $lockedRepository = $this->locker->getLockedRepository($withDevReqs);
 } catch (\RuntimeException $e) {

 if ($this->package->getDevRequires()) {
 throw $e;
 }

 $lockedRepository = $this->locker->getLockedRepository();
 }
 }

 $this->whitelistUpdateDependencies(
 $localRepo,
 $withDevReqs,
 $this->package->getRequires(),
 $this->package->getDevRequires()
 );

 $this->io->writeError('<info>Loading composer repositories with package information</info>');


 $policy = $this->createPolicy();
 $pool = $this->createPool($withDevReqs, $installFromLock ? $lockedRepository : null);
 $pool->addRepository($installedRepo, $aliases);
 if (!$installFromLock) {
 $repositories = $this->repositoryManager->getRepositories();
 foreach ($repositories as $repository) {
 $pool->addRepository($repository, $aliases);
 }
 }

 
 
 if ($lockedRepository) {
 $pool->addRepository($lockedRepository, $aliases);
 }


 $request = $this->createRequest($this->package, $platformRepo);

 if (!$installFromLock) {

 $removedUnstablePackages = array();
 foreach ($localRepo->getPackages() as $package) {
 if (
 !$pool->isPackageAcceptable($package->getNames(), $package->getStability())
 && $this->installationManager->isPackageInstalled($localRepo, $package)
 ) {
 $removedUnstablePackages[$package->getName()] = true;
 $request->remove($package->getName(), new VersionConstraint('=', $package->getVersion()));
 }
 }
 }

 if ($this->update) {
 $this->io->writeError('<info>Updating dependencies'.($withDevReqs ? ' (including require-dev)' : '').'</info>');

 $request->updateAll();

 if ($withDevReqs) {
 $links = array_merge($this->package->getRequires(), $this->package->getDevRequires());
 } else {
 $links = $this->package->getRequires();
 }

 foreach ($links as $link) {
 $request->install($link->getTarget(), $link->getConstraint());
 }


 
 if ($this->updateWhitelist) {
 $currentPackages = $this->getCurrentPackages($withDevReqs, $installedRepo);


 $candidates = array();
 foreach ($links as $link) {
 $candidates[$link->getTarget()] = true;
 }
 foreach ($localRepo->getPackages() as $package) {
 $candidates[$package->getName()] = true;
 }


 foreach ($candidates as $candidate => $dummy) {
 foreach ($currentPackages as $curPackage) {
 if ($curPackage->getName() === $candidate) {
 if (!$this->isUpdateable($curPackage) && !isset($removedUnstablePackages[$curPackage->getName()])) {
 $constraint = new VersionConstraint('=', $curPackage->getVersion());
 $request->install($curPackage->getName(), $constraint);
 }
 break;
 }
 }
 }
 }
 } elseif ($installFromLock) {
 $this->io->writeError('<info>Installing dependencies'.($withDevReqs ? ' (including require-dev)' : '').' from lock file</info>');

 if (!$this->locker->isFresh()) {
 $this->io->writeError('<warning>Warning: The lock file is not up to date with the latest changes in composer.json. You may be getting outdated dependencies. Run update to update them.</warning>');
 }

 foreach ($lockedRepository->getPackages() as $package) {
 $version = $package->getVersion();
 if (isset($aliases[$package->getName()][$version])) {
 $version = $aliases[$package->getName()][$version]['alias_normalized'];
 }
 $constraint = new VersionConstraint('=', $version);
 $constraint->setPrettyString($package->getPrettyVersion());
 $request->install($package->getName(), $constraint);
 }

 foreach ($this->locker->getPlatformRequirements($withDevReqs) as $link) {
 $request->install($link->getTarget(), $link->getConstraint());
 }
 } else {
 $this->io->writeError('<info>Installing dependencies'.($withDevReqs ? ' (including require-dev)' : '').'</info>');

 if ($withDevReqs) {
 $links = array_merge($this->package->getRequires(), $this->package->getDevRequires());
 } else {
 $links = $this->package->getRequires();
 }

 foreach ($links as $link) {
 $request->install($link->getTarget(), $link->getConstraint());
 }
 }


 $this->processDevPackages($localRepo, $pool, $policy, $repositories, $installedRepo, $lockedRepository, $installFromLock, $withDevReqs, 'force-links');


 $this->eventDispatcher->dispatchInstallerEvent(InstallerEvents::PRE_DEPENDENCIES_SOLVING, $this->devMode, $policy, $pool, $installedRepo, $request);
 $solver = new Solver($policy, $pool, $installedRepo);
 try {
 $operations = $solver->solve($request, $this->ignorePlatformReqs);
 $this->eventDispatcher->dispatchInstallerEvent(InstallerEvents::POST_DEPENDENCIES_SOLVING, $this->devMode, $policy, $pool, $installedRepo, $request, $operations);
 } catch (SolverProblemsException $e) {
 $this->io->writeError('<error>Your requirements could not be resolved to an installable set of packages.</error>');
 $this->io->writeError($e->getMessage());

 return max(1, $e->getCode());
 }

 if ($this->io->isVerbose()) {
 $this->io->writeError("Analyzed ".count($pool)." packages to resolve dependencies");
 $this->io->writeError("Analyzed ".$solver->getRuleSetSize()." rules to resolve dependencies");
 }


 $operations = $this->processDevPackages($localRepo, $pool, $policy, $repositories, $installedRepo, $lockedRepository, $installFromLock, $withDevReqs, 'force-updates', $operations);


 if (!$operations) {
 $this->io->writeError('Nothing to install or update');
 }

 $operations = $this->movePluginsToFront($operations);
 $operations = $this->moveUninstallsToFront($operations);

 foreach ($operations as $operation) {

 if ('install' === $operation->getJobType()) {
 foreach ($operation->getPackage()->getSuggests() as $target => $reason) {
 $this->suggestedPackages[] = array(
 'source' => $operation->getPackage()->getPrettyName(),
 'target' => $target,
 'reason' => $reason,
 );
 }
 }


 if (!$installFromLock) {
 $package = null;
 if ('update' === $operation->getJobType()) {
 $package = $operation->getTargetPackage();
 } elseif ('install' === $operation->getJobType()) {
 $package = $operation->getPackage();
 }
 if ($package && $package->isDev()) {
 $references = $this->package->getReferences();
 if (isset($references[$package->getName()])) {
 $package->setSourceReference($references[$package->getName()]);
 $package->setDistReference($references[$package->getName()]);
 }
 }
 if ('update' === $operation->getJobType()
 && $operation->getTargetPackage()->isDev()
 && $operation->getTargetPackage()->getVersion() === $operation->getInitialPackage()->getVersion()
 && $operation->getTargetPackage()->getSourceReference() === $operation->getInitialPackage()->getSourceReference()
 ) {
 if ($this->io->isDebug()) {
 $this->io->writeError('  - Skipping update of '. $operation->getTargetPackage()->getPrettyName().' to the same reference-locked version');
 $this->io->writeError('');
 }

 continue;
 }
 }

 $event = 'Composer\Installer\PackageEvents::PRE_PACKAGE_'.strtoupper($operation->getJobType());
 if (defined($event) && $this->runScripts) {
 $this->eventDispatcher->dispatchPackageEvent(constant($event), $this->devMode, $policy, $pool, $installedRepo, $request, $operations, $operation);
 }


 if ($this->dryRun && false === strpos($operation->getJobType(), 'Alias')) {
 $this->io->writeError('  - ' . $operation);
 $this->io->writeError('');
 } elseif ($this->io->isDebug() && false !== strpos($operation->getJobType(), 'Alias')) {
 $this->io->writeError('  - ' . $operation);
 $this->io->writeError('');
 }

 $this->installationManager->execute($localRepo, $operation);


 if ($this->verbose && $this->io->isVeryVerbose() && in_array($operation->getJobType(), array('install', 'update'))) {
 $reason = $operation->getReason();
 if ($reason instanceof Rule) {
 switch ($reason->getReason()) {
 case Rule::RULE_JOB_INSTALL:
 $this->io->writeError('    REASON: Required by root: '.$reason->getPrettyString($pool));
 $this->io->writeError('');
 break;
 case Rule::RULE_PACKAGE_REQUIRES:
 $this->io->writeError('    REASON: '.$reason->getPrettyString($pool));
 $this->io->writeError('');
 break;
 }
 }
 }

 $event = 'Composer\Installer\PackageEvents::POST_PACKAGE_'.strtoupper($operation->getJobType());
 if (defined($event) && $this->runScripts) {
 $this->eventDispatcher->dispatchPackageEvent(constant($event), $this->devMode, $policy, $pool, $installedRepo, $request, $operations, $operation);
 }

 if (!$this->dryRun) {
 $localRepo->write();
 }
 }

 if (!$this->dryRun) {

 $this->processPackageUrls($pool, $policy, $localRepo, $repositories);
 $localRepo->write();
 }

 return 0;
 }














 private function movePluginsToFront(array $operations)
 {
 $installerOps = array();
 foreach ($operations as $idx => $op) {
 if ($op instanceof InstallOperation) {
 $package = $op->getPackage();
 } elseif ($op instanceof UpdateOperation) {
 $package = $op->getTargetPackage();
 } else {
 continue;
 }

 if ($package->getType() === 'composer-plugin' || $package->getType() === 'composer-installer') {

 $requires = array_keys($package->getRequires());
 foreach ($requires as $index => $req) {
 if ($req === 'composer-plugin-api' || preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $req)) {
 unset($requires[$index]);
 }
 }

 if (!count($requires)) {
 $installerOps[] = $op;
 unset($operations[$idx]);
 }
 }
 }

 return array_merge($installerOps, $operations);
 }








 private function moveUninstallsToFront(array $operations)
 {
 $uninstOps = array();
 foreach ($operations as $idx => $op) {
 if ($op instanceof UninstallOperation) {
 $uninstOps[] = $op;
 unset($operations[$idx]);
 }
 }

 return array_merge($uninstOps, $operations);
 }






 private function createPool($withDevReqs, RepositoryInterface $lockedRepository = null)
 {
 if (!$this->update && $this->locker->isLocked()) { 
 $minimumStability = $this->locker->getMinimumStability();
 $stabilityFlags = $this->locker->getStabilityFlags();

 $requires = array();
 foreach ($lockedRepository->getPackages() as $package) {
 $constraint = new VersionConstraint('=', $package->getVersion());
 $constraint->setPrettyString($package->getPrettyVersion());
 $requires[$package->getName()] = $constraint;
 }
 } else {
 $minimumStability = $this->package->getMinimumStability();
 $stabilityFlags = $this->package->getStabilityFlags();

 $requires = $this->package->getRequires();
 if ($withDevReqs) {
 $requires = array_merge($requires, $this->package->getDevRequires());
 }
 }

 $rootConstraints = array();
 foreach ($requires as $req => $constraint) {

 if ($this->ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $req)) {
 continue;
 }
 if ($constraint instanceof Link) {
 $rootConstraints[$req] = $constraint->getConstraint();
 } else {
 $rootConstraints[$req] = $constraint;
 }
 }

 return new Pool($minimumStability, $stabilityFlags, $rootConstraints);
 }




 private function createPolicy()
 {
 $preferStable = null;
 $preferLowest = null;
 if (!$this->update && $this->locker->isLocked()) {
 $preferStable = $this->locker->getPreferStable();
 $preferLowest = $this->locker->getPreferLowest();
 }

 
 if (null === $preferStable) {
 $preferStable = $this->preferStable || $this->package->getPreferStable();
 }
 if (null === $preferLowest) {
 $preferLowest = $this->preferLowest;
 }

 return new DefaultPolicy($preferStable, $preferLowest);
 }






 private function createRequest(RootPackageInterface $rootPackage, PlatformRepository $platformRepo)
 {
 $request = new Request();

 $constraint = new VersionConstraint('=', $rootPackage->getVersion());
 $constraint->setPrettyString($rootPackage->getPrettyVersion());
 $request->install($rootPackage->getName(), $constraint);

 $fixedPackages = $platformRepo->getPackages();
 if ($this->additionalInstalledRepository) {
 $additionalFixedPackages = $this->additionalInstalledRepository->getPackages();
 $fixedPackages = array_merge($fixedPackages, $additionalFixedPackages);
 }


 
 $provided = $rootPackage->getProvides();
 foreach ($fixedPackages as $package) {
 $constraint = new VersionConstraint('=', $package->getVersion());
 $constraint->setPrettyString($package->getPrettyVersion());


 if ($package->getRepository() !== $platformRepo
 || !isset($provided[$package->getName()])
 || !$provided[$package->getName()]->getConstraint()->matches($constraint)
 ) {
 $request->fix($package->getName(), $constraint);
 }
 }

 return $request;
 }














 private function processDevPackages($localRepo, $pool, $policy, $repositories, $installedRepo, $lockedRepository, $installFromLock, $withDevReqs, $task, array $operations = null)
 {
 if ($task === 'force-updates' && null === $operations) {
 throw new \InvalidArgumentException('Missing operations argument');
 }
 if ($task === 'force-links') {
 $operations = array();
 }

 if (!$installFromLock && $this->updateWhitelist) {
 $currentPackages = $this->getCurrentPackages($withDevReqs, $installedRepo);
 }

 foreach ($localRepo->getCanonicalPackages() as $package) {

 if (!$package->isDev()) {
 continue;
 }


 foreach ($operations as $operation) {
 if (('update' === $operation->getJobType() && $operation->getInitialPackage()->equals($package))
 || ('uninstall' === $operation->getJobType() && $operation->getPackage()->equals($package))
 ) {
 continue 2;
 }
 }


 if ($installFromLock) {
 foreach ($lockedRepository->findPackages($package->getName()) as $lockedPackage) {
 if ($lockedPackage->isDev() && $lockedPackage->getVersion() === $package->getVersion()) {
 if ($task === 'force-links') {
 $package->setRequires($lockedPackage->getRequires());
 $package->setConflicts($lockedPackage->getConflicts());
 $package->setProvides($lockedPackage->getProvides());
 $package->setReplaces($lockedPackage->getReplaces());
 } elseif ($task === 'force-updates') {
 if (($lockedPackage->getSourceReference() && $lockedPackage->getSourceReference() !== $package->getSourceReference())
 || ($lockedPackage->getDistReference() && $lockedPackage->getDistReference() !== $package->getDistReference())
 ) {
 $operations[] = new UpdateOperation($package, $lockedPackage);
 }
 }

 break;
 }
 }
 } else {

 if ($this->update) {

 if ($this->updateWhitelist && !$this->isUpdateable($package)) {

 foreach ($currentPackages as $curPackage) {
 if ($curPackage->isDev() && $curPackage->getName() === $package->getName() && $curPackage->getVersion() === $package->getVersion()) {
 if ($task === 'force-links') {
 $package->setRequires($curPackage->getRequires());
 $package->setConflicts($curPackage->getConflicts());
 $package->setProvides($curPackage->getProvides());
 $package->setReplaces($curPackage->getReplaces());
 } elseif ($task === 'force-updates') {
 if (($curPackage->getSourceReference() && $curPackage->getSourceReference() !== $package->getSourceReference())
 || ($curPackage->getDistReference() && $curPackage->getDistReference() !== $package->getDistReference())
 ) {
 $operations[] = new UpdateOperation($package, $curPackage);
 }
 }

 break;
 }
 }

 continue;
 }


 $matches = $pool->whatProvides($package->getName(), new VersionConstraint('=', $package->getVersion()));
 foreach ($matches as $index => $match) {

 if (!in_array($match->getRepository(), $repositories, true)) {
 unset($matches[$index]);
 continue;
 }


 if ($match->getName() !== $package->getName()) {
 unset($matches[$index]);
 continue;
 }

 $matches[$index] = $match->getId();
 }


 if ($matches && $matches = $policy->selectPreferredPackages($pool, array(), $matches)) {
 $newPackage = $pool->literalToPackage($matches[0]);

 if ($task === 'force-links' && $newPackage) {
 $package->setRequires($newPackage->getRequires());
 $package->setConflicts($newPackage->getConflicts());
 $package->setProvides($newPackage->getProvides());
 $package->setReplaces($newPackage->getReplaces());
 }

 if ($task === 'force-updates' && $newPackage && (
 (($newPackage->getSourceReference() && $newPackage->getSourceReference() !== $package->getSourceReference())
 || ($newPackage->getDistReference() && $newPackage->getDistReference() !== $package->getDistReference())
 )
 )) {
 $operations[] = new UpdateOperation($package, $newPackage);
 }
 }
 }

 if ($task === 'force-updates') {

 $references = $this->package->getReferences();

 if (isset($references[$package->getName()]) && $references[$package->getName()] !== $package->getSourceReference()) {

 $operations[] = new UpdateOperation($package, clone $package);
 }
 }
 }
 }

 return $operations;
 }







 private function getCurrentPackages($withDevReqs, $installedRepo)
 {
 if ($this->locker->isLocked()) {
 try {
 return $this->locker->getLockedRepository($withDevReqs)->getPackages();
 } catch (\RuntimeException $e) {

 return $this->locker->getLockedRepository()->getPackages();
 }
 }

 return $installedRepo->getPackages();
 }




 private function getRootAliases()
 {
 if (!$this->update && $this->locker->isLocked()) {
 $aliases = $this->locker->getAliases();
 } else {
 $aliases = $this->package->getAliases();
 }

 $normalizedAliases = array();

 foreach ($aliases as $alias) {
 $normalizedAliases[$alias['package']][$alias['version']] = array(
 'alias' => $alias['alias'],
 'alias_normalized' => $alias['alias_normalized']
 );
 }

 return $normalizedAliases;
 }







 private function processPackageUrls($pool, $policy, $localRepo, $repositories)
 {
 if (!$this->update) {
 return;
 }

 foreach ($localRepo->getCanonicalPackages() as $package) {

 $matches = $pool->whatProvides($package->getName(), new VersionConstraint('=', $package->getVersion()));
 foreach ($matches as $index => $match) {

 if (!in_array($match->getRepository(), $repositories, true)) {
 unset($matches[$index]);
 continue;
 }


 if ($match->getName() !== $package->getName()) {
 unset($matches[$index]);
 continue;
 }

 $matches[$index] = $match->getId();
 }


 if ($matches && $matches = $policy->selectPreferredPackages($pool, array(), $matches)) {
 $newPackage = $pool->literalToPackage($matches[0]);


 $package->setSourceUrl($newPackage->getSourceUrl());

 
 if (preg_match('{^https?://(?:(?:www\.)?bitbucket\.org|(api\.)?github\.com)/}', $newPackage->getDistUrl())) {
 $package->setDistUrl($newPackage->getDistUrl());
 }
 }
 }
 }





 private function aliasPlatformPackages(PlatformRepository $platformRepo, $aliases)
 {
 foreach ($aliases as $package => $versions) {
 foreach ($versions as $version => $alias) {
 $packages = $platformRepo->findPackages($package, $version);
 foreach ($packages as $package) {
 $aliasPackage = new AliasPackage($package, $alias['alias_normalized'], $alias['alias']);
 $aliasPackage->setRootPackageAlias(true);
 $platformRepo->addPackage($aliasPackage);
 }
 }
 }
 }





 private function isUpdateable(PackageInterface $package)
 {
 if (!$this->updateWhitelist) {
 throw new \LogicException('isUpdateable should only be called when a whitelist is present');
 }

 foreach ($this->updateWhitelist as $whiteListedPattern => $void) {
 $patternRegexp = $this->packageNameToRegexp($whiteListedPattern);
 if (preg_match($patternRegexp, $package->getName())) {
 return true;
 }
 }

 return false;
 }







 private function packageNameToRegexp($whiteListedPattern)
 {
 $cleanedWhiteListedPattern = str_replace('\\*', '.*', preg_quote($whiteListedPattern));

 return "{^" . $cleanedWhiteListedPattern . "$}i";
 }





 private function extractPlatformRequirements($links)
 {
 $platformReqs = array();
 foreach ($links as $link) {
 if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $link->getTarget())) {
 $platformReqs[$link->getTarget()] = $link->getPrettyConstraint();
 }
 }

 return $platformReqs;
 }













 private function whitelistUpdateDependencies($localRepo, $devMode, array $rootRequires, array $rootDevRequires)
 {
 if (!$this->updateWhitelist) {
 return;
 }

 $requiredPackageNames = array();
 foreach (array_merge($rootRequires, $rootDevRequires) as $require) {
 $requiredPackageNames[] = $require->getTarget();
 }

 if ($devMode) {
 $rootRequires = array_merge($rootRequires, $rootDevRequires);
 }

 $skipPackages = array();
 foreach ($rootRequires as $require) {
 $skipPackages[$require->getTarget()] = true;
 }

 $pool = new Pool;
 $pool->addRepository($localRepo);

 $seen = array();

 $rootRequiredPackageNames = array_keys($rootRequires);

 foreach ($this->updateWhitelist as $packageName => $void) {
 $packageQueue = new \SplQueue;

 $depPackages = $pool->whatProvides($packageName);

 $nameMatchesRequiredPackage = in_array($packageName, $requiredPackageNames, true);


 if (!$nameMatchesRequiredPackage) {
 $whitelistPatternRegexp = $this->packageNameToRegexp($packageName);
 foreach ($rootRequiredPackageNames as $rootRequiredPackageName) {
 if (preg_match($whitelistPatternRegexp, $rootRequiredPackageName)) {
 $nameMatchesRequiredPackage = true;
 break;
 }
 }
 }

 if (count($depPackages) == 0 && !$nameMatchesRequiredPackage && !in_array($packageName, array('nothing', 'lock'))) {
 $this->io->writeError('<warning>Package "' . $packageName . '" listed for update is not installed. Ignoring.</warning>');
 }

 foreach ($depPackages as $depPackage) {
 $packageQueue->enqueue($depPackage);
 }

 while (!$packageQueue->isEmpty()) {
 $package = $packageQueue->dequeue();
 if (isset($seen[$package->getId()])) {
 continue;
 }

 $seen[$package->getId()] = true;
 $this->updateWhitelist[$package->getName()] = true;

 if (!$this->whitelistDependencies) {
 continue;
 }

 $requires = $package->getRequires();

 foreach ($requires as $require) {
 $requirePackages = $pool->whatProvides($require->getTarget());

 foreach ($requirePackages as $requirePackage) {
 if (isset($skipPackages[$requirePackage->getName()])) {
 continue;
 }
 $packageQueue->enqueue($requirePackage);
 }
 }
 }
 }
 }








 private function mockLocalRepositories(RepositoryManager $rm)
 {
 $packages = array();
 foreach ($rm->getLocalRepository()->getPackages() as $package) {
 $packages[(string) $package] = clone $package;
 }
 foreach ($packages as $key => $package) {
 if ($package instanceof AliasPackage) {
 $alias = (string) $package->getAliasOf();
 $packages[$key] = new AliasPackage($packages[$alias], $package->getVersion(), $package->getPrettyVersion());
 }
 }
 $rm->setLocalRepository(
 new InstalledArrayRepository($packages)
 );
 }








 public static function create(IOInterface $io, Composer $composer)
 {
 return new static(
 $io,
 $composer->getConfig(),
 $composer->getPackage(),
 $composer->getDownloadManager(),
 $composer->getRepositoryManager(),
 $composer->getLocker(),
 $composer->getInstallationManager(),
 $composer->getEventDispatcher(),
 $composer->getAutoloadGenerator()
 );
 }





 public function setAdditionalInstalledRepository(RepositoryInterface $additionalInstalledRepository)
 {
 $this->additionalInstalledRepository = $additionalInstalledRepository;

 return $this;
 }







 public function setDryRun($dryRun = true)
 {
 $this->dryRun = (boolean) $dryRun;

 return $this;
 }






 public function isDryRun()
 {
 return $this->dryRun;
 }







 public function setPreferSource($preferSource = true)
 {
 $this->preferSource = (boolean) $preferSource;

 return $this;
 }







 public function setPreferDist($preferDist = true)
 {
 $this->preferDist = (boolean) $preferDist;

 return $this;
 }







 public function setOptimizeAutoloader($optimizeAutoloader = false)
 {
 $this->optimizeAutoloader = (boolean) $optimizeAutoloader;

 return $this;
 }







 public function setUpdate($update = true)
 {
 $this->update = (boolean) $update;

 return $this;
 }







 public function setDevMode($devMode = true)
 {
 $this->devMode = (boolean) $devMode;

 return $this;
 }







 public function setDumpAutoloader($dumpAutoloader = true)
 {
 $this->dumpAutoloader = (boolean) $dumpAutoloader;

 return $this;
 }







 public function setRunScripts($runScripts = true)
 {
 $this->runScripts = (boolean) $runScripts;

 return $this;
 }







 public function setConfig(Config $config)
 {
 $this->config = $config;

 return $this;
 }







 public function setVerbose($verbose = true)
 {
 $this->verbose = (boolean) $verbose;

 return $this;
 }






 public function isVerbose()
 {
 return $this->verbose;
 }







 public function setIgnorePlatformRequirements($ignorePlatformReqs = false)
 {
 $this->ignorePlatformReqs = (boolean) $ignorePlatformReqs;

 return $this;
 }








 public function setUpdateWhitelist(array $packages)
 {
 $this->updateWhitelist = array_flip(array_map('strtolower', $packages));

 return $this;
 }







 public function setWhitelistDependencies($updateDependencies = true)
 {
 $this->whitelistDependencies = (boolean) $updateDependencies;

 return $this;
 }







 public function setPreferStable($preferStable = true)
 {
 $this->preferStable = (boolean) $preferStable;

 return $this;
 }







 public function setPreferLowest($preferLowest = true)
 {
 $this->preferLowest = (boolean) $preferLowest;

 return $this;
 }










 public function disablePlugins()
 {
 $this->installationManager->disablePlugins();

 return $this;
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Package\PackageInterface;
 use Composer\Package\AliasPackage;
 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\DependencyResolver\Operation\OperationInterface;
 use Composer\DependencyResolver\Operation\InstallOperation;
 use Composer\DependencyResolver\Operation\UpdateOperation;
 use Composer\DependencyResolver\Operation\UninstallOperation;
 use Composer\DependencyResolver\Operation\MarkAliasInstalledOperation;
 use Composer\DependencyResolver\Operation\MarkAliasUninstalledOperation;
 use Composer\Util\StreamContextFactory;








 class InstallationManager
 {
 private $installers = array();
 private $cache = array();
 private $notifiablePackages = array();

 public function reset()
 {
 $this->notifiablePackages = array();
 }






 public function addInstaller(InstallerInterface $installer)
 {
 array_unshift($this->installers, $installer);
 $this->cache = array();
 }






 public function removeInstaller(InstallerInterface $installer)
 {
 if (false !== ($key = array_search($installer, $this->installers, true))) {
 array_splice($this->installers, $key, 1);
 $this->cache = array();
 }
 }








 public function disablePlugins()
 {
 foreach ($this->installers as $i => $installer) {
 if (!$installer instanceof PluginInstaller) {
 continue;
 }

 unset($this->installers[$i]);
 }
 }










 public function getInstaller($type)
 {
 $type = strtolower($type);

 if (isset($this->cache[$type])) {
 return $this->cache[$type];
 }

 foreach ($this->installers as $installer) {
 if ($installer->supports($type)) {
 return $this->cache[$type] = $installer;
 }
 }

 throw new \InvalidArgumentException('Unknown installer type: '.$type);
 }









 public function isPackageInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 if ($package instanceof AliasPackage) {
 return $repo->hasPackage($package) && $this->isPackageInstalled($repo, $package->getAliasOf());
 }

 return $this->getInstaller($package->getType())->isInstalled($repo, $package);
 }







 public function execute(RepositoryInterface $repo, OperationInterface $operation)
 {
 $method = $operation->getJobType();
 $this->$method($repo, $operation);
 }







 public function install(RepositoryInterface $repo, InstallOperation $operation)
 {
 $package = $operation->getPackage();
 $installer = $this->getInstaller($package->getType());
 $installer->install($repo, $package);
 $this->markForNotification($package);
 }







 public function update(RepositoryInterface $repo, UpdateOperation $operation)
 {
 $initial = $operation->getInitialPackage();
 $target = $operation->getTargetPackage();

 $initialType = $initial->getType();
 $targetType = $target->getType();

 if ($initialType === $targetType) {
 $installer = $this->getInstaller($initialType);
 $installer->update($repo, $initial, $target);
 $this->markForNotification($target);
 } else {
 $this->getInstaller($initialType)->uninstall($repo, $initial);
 $this->getInstaller($targetType)->install($repo, $target);
 }
 }







 public function uninstall(RepositoryInterface $repo, UninstallOperation $operation)
 {
 $package = $operation->getPackage();
 $installer = $this->getInstaller($package->getType());
 $installer->uninstall($repo, $package);
 }







 public function markAliasInstalled(RepositoryInterface $repo, MarkAliasInstalledOperation $operation)
 {
 $package = $operation->getPackage();

 if (!$repo->hasPackage($package)) {
 $repo->addPackage(clone $package);
 }
 }







 public function markAliasUninstalled(RepositoryInterface $repo, MarkAliasUninstalledOperation $operation)
 {
 $package = $operation->getPackage();

 $repo->removePackage($package);
 }







 public function getInstallPath(PackageInterface $package)
 {
 $installer = $this->getInstaller($package->getType());

 return $installer->getInstallPath($package);
 }

 public function notifyInstalls()
 {
 foreach ($this->notifiablePackages as $repoUrl => $packages) {

 if (strpos($repoUrl, '%package%')) {
 foreach ($packages as $package) {
 $url = str_replace('%package%', $package->getPrettyName(), $repoUrl);

 $params = array(
 'version' => $package->getPrettyVersion(),
 'version_normalized' => $package->getVersion(),
 );
 $opts = array('http' =>
 array(
 'method' => 'POST',
 'header' => array('Content-type: application/x-www-form-urlencoded'),
 'content' => http_build_query($params, '', '&'),
 'timeout' => 3,
 )
 );

 $context = StreamContextFactory::getContext($url, $opts);
 @file_get_contents($url, false, $context);
 }

 continue;
 }

 $postData = array('downloads' => array());
 foreach ($packages as $package) {
 $postData['downloads'][] = array(
 'name' => $package->getPrettyName(),
 'version' => $package->getVersion(),
 );
 }

 $opts = array('http' =>
 array(
 'method' => 'POST',
 'header' => array('Content-Type: application/json'),
 'content' => json_encode($postData),
 'timeout' => 6,
 )
 );

 $context = StreamContextFactory::getContext($repoUrl, $opts);
 @file_get_contents($repoUrl, false, $context);
 }

 $this->reset();
 }

 private function markForNotification(PackageInterface $package)
 {
 if ($package->getNotificationUrl()) {
 $this->notifiablePackages[$package->getNotificationUrl()][$package->getName()] = $package;
 }
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Composer;
 use Composer\DependencyResolver\PolicyInterface;
 use Composer\DependencyResolver\Operation\OperationInterface;
 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\Request;
 use Composer\EventDispatcher\Event;
 use Composer\IO\IOInterface;
 use Composer\Repository\CompositeRepository;






 class InstallerEvent extends Event
 {



 private $composer;




 private $io;




 private $devMode;




 private $policy;




 private $pool;




 private $installedRepo;




 private $request;




 private $operations;














 public function __construct($eventName, Composer $composer, IOInterface $io, $devMode, PolicyInterface $policy, Pool $pool, CompositeRepository $installedRepo, Request $request, array $operations = array())
 {
 parent::__construct($eventName);

 $this->composer = $composer;
 $this->io = $io;
 $this->devMode = $devMode;
 $this->policy = $policy;
 $this->pool = $pool;
 $this->installedRepo = $installedRepo;
 $this->request = $request;
 $this->operations = $operations;
 }




 public function getComposer()
 {
 return $this->composer;
 }




 public function getIO()
 {
 return $this->io;
 }




 public function isDevMode()
 {
 return $this->devMode;
 }




 public function getPolicy()
 {
 return $this->policy;
 }




 public function getPool()
 {
 return $this->pool;
 }




 public function getInstalledRepo()
 {
 return $this->installedRepo;
 }




 public function getRequest()
 {
 return $this->request;
 }




 public function getOperations()
 {
 return $this->operations;
 }
 }
 <?php











 namespace Composer\Installer;






 class InstallerEvents
 {









 const PRE_DEPENDENCIES_SOLVING = 'pre-dependencies-solving';










 const POST_DEPENDENCIES_SOLVING = 'post-dependencies-solving';
 }
 <?php











 namespace Composer\Installer;

 use Composer\Package\PackageInterface;
 use Composer\Repository\InstalledRepositoryInterface;
 use InvalidArgumentException;







 interface InstallerInterface
 {






 public function supports($packageType);









 public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package);







 public function install(InstalledRepositoryInterface $repo, PackageInterface $package);










 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target);







 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package);







 public function getInstallPath(PackageInterface $package);
 }
 <?php











 namespace Composer\Installer;

 use Composer\Composer;
 use Composer\IO\IOInterface;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Package\PackageInterface;
 use Composer\Util\Filesystem;
 use Composer\Util\ProcessExecutor;







 class LibraryInstaller implements InstallerInterface
 {
 protected $composer;
 protected $vendorDir;
 protected $binDir;
 protected $downloadManager;
 protected $io;
 protected $type;
 protected $filesystem;









 public function __construct(IOInterface $io, Composer $composer, $type = 'library', Filesystem $filesystem = null)
 {
 $this->composer = $composer;
 $this->downloadManager = $composer->getDownloadManager();
 $this->io = $io;
 $this->type = $type;

 $this->filesystem = $filesystem ?: new Filesystem();
 $this->vendorDir = rtrim($composer->getConfig()->get('vendor-dir'), '/');
 $this->binDir = rtrim($composer->getConfig()->get('bin-dir'), '/');
 }




 public function supports($packageType)
 {
 return $packageType === $this->type || null === $this->type;
 }




 public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 return $repo->hasPackage($package) && is_readable($this->getInstallPath($package));
 }




 public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 $this->initializeVendorDir();
 $downloadPath = $this->getInstallPath($package);


 if (!is_readable($downloadPath) && $repo->hasPackage($package)) {
 $this->removeBinaries($package);
 }

 $this->installCode($package);
 $this->installBinaries($package);
 if (!$repo->hasPackage($package)) {
 $repo->addPackage(clone $package);
 }
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 if (!$repo->hasPackage($initial)) {
 throw new \InvalidArgumentException('Package is not installed: '.$initial);
 }

 $this->initializeVendorDir();

 $this->removeBinaries($initial);
 $this->updateCode($initial, $target);
 $this->installBinaries($target);
 $repo->removePackage($initial);
 if (!$repo->hasPackage($target)) {
 $repo->addPackage(clone $target);
 }
 }




 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 if (!$repo->hasPackage($package)) {
 throw new \InvalidArgumentException('Package is not installed: '.$package);
 }

 $this->removeCode($package);
 $this->removeBinaries($package);
 $repo->removePackage($package);

 $downloadPath = $this->getPackageBasePath($package);
 if (strpos($package->getName(), '/')) {
 $packageVendorDir = dirname($downloadPath);
 if (is_dir($packageVendorDir) && $this->filesystem->isDirEmpty($packageVendorDir)) {
 @rmdir($packageVendorDir);
 }
 }
 }




 public function getInstallPath(PackageInterface $package)
 {
 $targetDir = $package->getTargetDir();

 return $this->getPackageBasePath($package) . ($targetDir ? '/'.$targetDir : '');
 }

 protected function getPackageBasePath(PackageInterface $package)
 {
 $this->initializeVendorDir();

 return ($this->vendorDir ? $this->vendorDir.'/' : '') . $package->getPrettyName();
 }

 protected function installCode(PackageInterface $package)
 {
 $downloadPath = $this->getInstallPath($package);
 $this->downloadManager->download($package, $downloadPath);
 }

 protected function updateCode(PackageInterface $initial, PackageInterface $target)
 {
 $initialDownloadPath = $this->getInstallPath($initial);
 $targetDownloadPath = $this->getInstallPath($target);
 if ($targetDownloadPath !== $initialDownloadPath) {

 
 if (substr($initialDownloadPath, 0, strlen($targetDownloadPath)) === $targetDownloadPath
 || substr($targetDownloadPath, 0, strlen($initialDownloadPath)) === $initialDownloadPath
 ) {
 $this->removeCode($initial);
 $this->installCode($target);

 return;
 }

 $this->filesystem->rename($initialDownloadPath, $targetDownloadPath);
 }
 $this->downloadManager->update($initial, $target, $targetDownloadPath);
 }

 protected function removeCode(PackageInterface $package)
 {
 $downloadPath = $this->getPackageBasePath($package);
 $this->downloadManager->remove($package, $downloadPath);
 }

 protected function getBinaries(PackageInterface $package)
 {
 return $package->getBinaries();
 }

 protected function installBinaries(PackageInterface $package)
 {
 $binaries = $this->getBinaries($package);
 if (!$binaries) {
 return;
 }
 foreach ($binaries as $bin) {
 $binPath = $this->getInstallPath($package).'/'.$bin;
 if (!file_exists($binPath)) {
 $this->io->writeError('    <warning>Skipped installation of bin '.$bin.' for package '.$package->getName().': file not found in package</warning>');
 continue;
 }


 
 
 
 $binPath = realpath($binPath);

 $this->initializeBinDir();
 $link = $this->binDir.'/'.basename($bin);
 if (file_exists($link)) {
 if (is_link($link)) {

 
 
 @chmod($link, 0777 & ~umask());
 }
 $this->io->writeError('    Skipped installation of bin '.$bin.' for package '.$package->getName().': name conflicts with an existing file');
 continue;
 }
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {

 if ('.bat' !== substr($binPath, -4)) {
 file_put_contents($link, $this->generateUnixyProxyCode($binPath, $link));
 @chmod($link, 0777 & ~umask());
 $link .= '.bat';
 if (file_exists($link)) {
 $this->io->writeError('    Skipped installation of bin '.$bin.'.bat proxy for package '.$package->getName().': a .bat proxy was already installed');
 }
 }
 if (!file_exists($link)) {
 file_put_contents($link, $this->generateWindowsProxyCode($binPath, $link));
 }
 } else {
 $cwd = getcwd();
 try {

 
 $relativeBin = $this->filesystem->findShortestPath($link, $binPath);
 chdir(dirname($link));
 if (false === @symlink($relativeBin, $link)) {
 throw new \ErrorException();
 }
 } catch (\ErrorException $e) {
 file_put_contents($link, $this->generateUnixyProxyCode($binPath, $link));
 }
 chdir($cwd);
 }
 @chmod($link, 0777 & ~umask());
 }
 }

 protected function removeBinaries(PackageInterface $package)
 {
 $binaries = $this->getBinaries($package);
 if (!$binaries) {
 return;
 }
 foreach ($binaries as $bin) {
 $link = $this->binDir.'/'.basename($bin);
 if (is_link($link) || file_exists($link)) {
 $this->filesystem->unlink($link);
 }
 if (file_exists($link.'.bat')) {
 $this->filesystem->unlink($link.'.bat');
 }
 }
 }

 protected function initializeVendorDir()
 {
 $this->filesystem->ensureDirectoryExists($this->vendorDir);
 $this->vendorDir = realpath($this->vendorDir);
 }

 protected function initializeBinDir()
 {
 $this->filesystem->ensureDirectoryExists($this->binDir);
 $this->binDir = realpath($this->binDir);
 }

 protected function generateWindowsProxyCode($bin, $link)
 {
 $binPath = $this->filesystem->findShortestPath($link, $bin);
 if ('.bat' === substr($bin, -4) || '.exe' === substr($bin, -4)) {
 $caller = 'call';
 } else {
 $handle = fopen($bin, 'r');
 $line = fgets($handle);
 fclose($handle);
 if (preg_match('{^#!/(?:usr/bin/env )?(?:[^/]+/)*(.+)$}m', $line, $match)) {
 $caller = trim($match[1]);
 } else {
 $caller = 'php';
 }
 }

 return "@ECHO OFF\r\n".
 "SET BIN_TARGET=%~dp0/".trim(ProcessExecutor::escape($binPath), '"')."\r\n".
 "{$caller} \"%BIN_TARGET%\" %*\r\n";
 }

 protected function generateUnixyProxyCode($bin, $link)
 {
 $binPath = $this->filesystem->findShortestPath($link, $bin);

 return "#!/usr/bin/env sh\n".
 'SRC_DIR="`pwd`"'."\n".
 'cd "`dirname "$0"`"'."\n".
 'cd '.ProcessExecutor::escape(dirname($binPath))."\n".
 'BIN_TARGET="`pwd`/'.basename($binPath)."\"\n".
 'cd "$SRC_DIR"'."\n".
 '"$BIN_TARGET" "$@"'."\n";
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Package\PackageInterface;






 class MetapackageInstaller implements InstallerInterface
 {



 public function supports($packageType)
 {
 return $packageType === 'metapackage';
 }




 public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 return $repo->hasPackage($package);
 }




 public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 $repo->addPackage(clone $package);
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 if (!$repo->hasPackage($initial)) {
 throw new \InvalidArgumentException('Package is not installed: '.$initial);
 }

 $repo->removePackage($initial);
 $repo->addPackage(clone $target);
 }




 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 if (!$repo->hasPackage($package)) {
 throw new \InvalidArgumentException('Package is not installed: '.$package);
 }

 $repo->removePackage($package);
 }




 public function getInstallPath(PackageInterface $package)
 {
 return '';
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Package\PackageInterface;








 class NoopInstaller implements InstallerInterface
 {



 public function supports($packageType)
 {
 return true;
 }




 public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 return $repo->hasPackage($package);
 }




 public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 if (!$repo->hasPackage($package)) {
 $repo->addPackage(clone $package);
 }
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 if (!$repo->hasPackage($initial)) {
 throw new \InvalidArgumentException('Package is not installed: '.$initial);
 }

 $repo->removePackage($initial);
 if (!$repo->hasPackage($target)) {
 $repo->addPackage(clone $target);
 }
 }




 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 if (!$repo->hasPackage($package)) {
 throw new \InvalidArgumentException('Package is not installed: '.$package);
 }
 $repo->removePackage($package);
 }




 public function getInstallPath(PackageInterface $package)
 {
 $targetDir = $package->getTargetDir();

 return $package->getPrettyName() . ($targetDir ? '/'.$targetDir : '');
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Composer;
 use Composer\IO\IOInterface;
 use Composer\DependencyResolver\Operation\OperationInterface;
 use Composer\DependencyResolver\PolicyInterface;
 use Composer\DependencyResolver\Pool;
 use Composer\DependencyResolver\Request;
 use Composer\Repository\CompositeRepository;






 class PackageEvent extends InstallerEvent
 {



 private $operation;















 public function __construct($eventName, Composer $composer, IOInterface $io, $devMode, PolicyInterface $policy, Pool $pool, CompositeRepository $installedRepo, Request $request, array $operations, OperationInterface $operation)
 {
 parent::__construct($eventName, $composer, $io, $devMode, $policy, $pool, $installedRepo, $request, $operations);

 $this->operation = $operation;
 }






 public function getOperation()
 {
 return $this->operation;
 }
 }
 <?php











 namespace Composer\Installer;






 class PackageEvents
 {







 const PRE_PACKAGE_INSTALL = 'pre-package-install';








 const POST_PACKAGE_INSTALL = 'post-package-install';








 const PRE_PACKAGE_UPDATE = 'pre-package-update';








 const POST_PACKAGE_UPDATE = 'post-package-update';








 const PRE_PACKAGE_UNINSTALL = 'pre-package-uninstall';








 const POST_PACKAGE_UNINSTALL = 'post-package-uninstall';
 }
 <?php











 namespace Composer\Installer;

 use Composer\IO\IOInterface;
 use Composer\Composer;
 use Composer\Downloader\PearPackageExtractor;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Package\PackageInterface;
 use Composer\Util\ProcessExecutor;







 class PearInstaller extends LibraryInstaller
 {







 public function __construct(IOInterface $io, Composer $composer, $type = 'pear-library')
 {
 parent::__construct($io, $composer, $type);
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 $this->uninstall($repo, $initial);
 $this->install($repo, $target);
 }

 protected function installCode(PackageInterface $package)
 {
 parent::installCode($package);
 parent::initializeBinDir();

 $isWindows = defined('PHP_WINDOWS_VERSION_BUILD');
 $php_bin = $this->binDir . ($isWindows ? '/composer-php.bat' : '/composer-php');

 if (!$isWindows) {
 $php_bin = '/usr/bin/env ' . $php_bin;
 }

 $installPath = $this->getInstallPath($package);
 $vars = array(
 'os' => $isWindows ? 'windows' : 'linux',
 'php_bin' => $php_bin,
 'pear_php' => $installPath,
 'php_dir' => $installPath,
 'bin_dir' => $installPath . '/bin',
 'data_dir' => $installPath . '/data',
 'version' => $package->getPrettyVersion(),
 );

 $packageArchive = $this->getInstallPath($package).'/'.pathinfo($package->getDistUrl(), PATHINFO_BASENAME);
 $pearExtractor = new PearPackageExtractor($packageArchive);
 $pearExtractor->extractTo($this->getInstallPath($package), array('php' => '/', 'script' => '/bin', 'data' => '/data'), $vars);

 if ($this->io->isVerbose()) {
 $this->io->writeError('    Cleaning up');
 }
 $this->filesystem->unlink($packageArchive);
 }

 protected function getBinaries(PackageInterface $package)
 {
 $binariesPath = $this->getInstallPath($package) . '/bin/';
 $binaries = array();
 if (file_exists($binariesPath)) {
 foreach (new \FilesystemIterator($binariesPath, \FilesystemIterator::KEY_AS_FILENAME | \FilesystemIterator::CURRENT_AS_FILEINFO) as $fileName => $value) {
 if (!$value->isDir()) {
 $binaries[] = 'bin/'.$fileName;
 }
 }
 }

 return $binaries;
 }

 protected function initializeBinDir()
 {
 parent::initializeBinDir();
 file_put_contents($this->binDir.'/composer-php', $this->generateUnixyPhpProxyCode());
 @chmod($this->binDir.'/composer-php', 0777);
 file_put_contents($this->binDir.'/composer-php.bat', $this->generateWindowsPhpProxyCode());
 @chmod($this->binDir.'/composer-php.bat', 0777);
 }

 protected function generateWindowsProxyCode($bin, $link)
 {
 $binPath = $this->filesystem->findShortestPath($link, $bin);
 if ('.bat' === substr($bin, -4)) {
 $caller = 'call';
 } else {
 $handle = fopen($bin, 'r');
 $line = fgets($handle);
 fclose($handle);
 if (preg_match('{^#!/(?:usr/bin/env )?(?:[^/]+/)*(.+)$}m', $line, $match)) {
 $caller = trim($match[1]);
 } else {
 $caller = 'php';
 }

 if ($caller === 'php') {
 return "@echo off\r\n".
 "pushd .\r\n".
 "cd %~dp0\r\n".
 "set PHP_PROXY=%CD%\\composer-php.bat\r\n".
 "cd ".ProcessExecutor::escape(dirname($binPath))."\r\n".
 "set BIN_TARGET=%CD%\\".basename($binPath)."\r\n".
 "popd\r\n".
 "%PHP_PROXY% \"%BIN_TARGET%\" %*\r\n";
 }
 }

 return "@echo off\r\n".
 "pushd .\r\n".
 "cd %~dp0\r\n".
 "cd ".ProcessExecutor::escape(dirname($binPath))."\r\n".
 "set BIN_TARGET=%CD%\\".basename($binPath)."\r\n".
 "popd\r\n".
 $caller." \"%BIN_TARGET%\" %*\r\n";
 }

 private function generateWindowsPhpProxyCode()
 {
 $binToVendor = $this->filesystem->findShortestPath($this->binDir, $this->vendorDir, true);

 return
 "@echo off\r\n" .
 "setlocal enabledelayedexpansion\r\n" .
 "set BIN_DIR=%~dp0\r\n" .
 "set VENDOR_DIR=%BIN_DIR%\\".$binToVendor."\r\n" .
 "set DIRS=.\r\n" .
 "FOR /D %%V IN (%VENDOR_DIR%\\*) DO (\r\n" .
 "    FOR /D %%P IN (%%V\\*) DO (\r\n" .
 "        set DIRS=!DIRS!;%%~fP\r\n" .
 "    )\r\n" .
 ")\r\n" .
 "php.exe -d include_path=!DIRS! %*\r\n";
 }

 private function generateUnixyPhpProxyCode()
 {
 $binToVendor = $this->filesystem->findShortestPath($this->binDir, $this->vendorDir, true);

 return
 "#!/usr/bin/env sh\n".
 "SRC_DIR=`pwd`\n".
 "BIN_DIR=`dirname $0`\n".
 "VENDOR_DIR=\$BIN_DIR/".escapeshellarg($binToVendor)."\n".
 "DIRS=\"\"\n".
 "for vendor in \$VENDOR_DIR/*; do\n".
 "    if [ -d \"\$vendor\" ]; then\n".
 "        for package in \$vendor/*; do\n".
 "            if [ -d \"\$package\" ]; then\n".
 "                DIRS=\"\${DIRS}:\${package}\"\n".
 "            fi\n".
 "        done\n".
 "    fi\n".
 "done\n".
 "php -d include_path=\".\$DIRS\" $@\n";
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Composer;
 use Composer\IO\IOInterface;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Package\PackageInterface;







 class PluginInstaller extends LibraryInstaller
 {
 private $installationManager;








 public function __construct(IOInterface $io, Composer $composer, $type = 'library')
 {
 parent::__construct($io, $composer, 'composer-plugin');
 $this->installationManager = $composer->getInstallationManager();
 }




 public function supports($packageType)
 {
 return $packageType === 'composer-plugin' || $packageType === 'composer-installer';
 }




 public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 $extra = $package->getExtra();
 if (empty($extra['class'])) {
 throw new \UnexpectedValueException('Error while installing '.$package->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
 }

 parent::install($repo, $package);
 $this->composer->getPluginManager()->registerPackage($package, true);
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 $extra = $target->getExtra();
 if (empty($extra['class'])) {
 throw new \UnexpectedValueException('Error while installing '.$target->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
 }

 parent::update($repo, $initial, $target);
 $this->composer->getPluginManager()->registerPackage($target, true);
 }
 }
 <?php











 namespace Composer\Installer;

 use Composer\Package\PackageInterface;
 use Composer\Downloader\DownloadManager;
 use Composer\Repository\InstalledRepositoryInterface;
 use Composer\Util\Filesystem;







 class ProjectInstaller implements InstallerInterface
 {
 private $installPath;
 private $downloadManager;
 private $filesystem;

 public function __construct($installPath, DownloadManager $dm)
 {
 $this->installPath = rtrim(strtr($installPath, '\\', '/'), '/').'/';
 $this->downloadManager = $dm;
 $this->filesystem = new Filesystem;
 }







 public function supports($packageType)
 {
 return true;
 }




 public function isInstalled(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 return false;
 }




 public function install(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 $installPath = $this->installPath;
 if (file_exists($installPath) && !$this->filesystem->isDirEmpty($installPath)) {
 throw new \InvalidArgumentException("Project directory $installPath is not empty.");
 }
 if (!is_dir($installPath)) {
 mkdir($installPath, 0777, true);
 }
 $this->downloadManager->download($package, $installPath);
 }




 public function update(InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
 {
 throw new \InvalidArgumentException("not supported");
 }




 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
 throw new \InvalidArgumentException("not supported");
 }







 public function getInstallPath(PackageInterface $package)
 {
 return $this->installPath;
 }
 }
 <?php











 namespace Composer\Json;

 use JsonSchema\Validator;
 use Seld\JsonLint\JsonParser;
 use Seld\JsonLint\ParsingException;
 use Composer\Util\RemoteFilesystem;
 use Composer\Downloader\TransportException;







 class JsonFile
 {
 const LAX_SCHEMA = 1;
 const STRICT_SCHEMA = 2;

 const JSON_UNESCAPED_SLASHES = 64;
 const JSON_PRETTY_PRINT = 128;
 const JSON_UNESCAPED_UNICODE = 256;

 private $path;
 private $rfs;








 public function __construct($path, RemoteFilesystem $rfs = null)
 {
 $this->path = $path;

 if (null === $rfs && preg_match('{^https?://}i', $path)) {
 throw new \InvalidArgumentException('http urls require a RemoteFilesystem instance to be passed');
 }
 $this->rfs = $rfs;
 }




 public function getPath()
 {
 return $this->path;
 }






 public function exists()
 {
 return is_file($this->path);
 }







 public function read()
 {
 try {
 if ($this->rfs) {
 $json = $this->rfs->getContents($this->path, $this->path, false);
 } else {
 $json = file_get_contents($this->path);
 }
 } catch (TransportException $e) {
 throw new \RuntimeException($e->getMessage(), 0, $e);
 } catch (\Exception $e) {
 throw new \RuntimeException('Could not read '.$this->path."\n\n".$e->getMessage());
 }

 return static::parseJson($json, $this->path);
 }








 public function write(array $hash, $options = 448)
 {
 $dir = dirname($this->path);
 if (!is_dir($dir)) {
 if (file_exists($dir)) {
 throw new \UnexpectedValueException(
 $dir.' exists and is not a directory.'
 );
 }
 if (!@mkdir($dir, 0777, true)) {
 throw new \UnexpectedValueException(
 $dir.' does not exist and could not be created.'
 );
 }
 }

 $retries = 3;
 while ($retries--) {
 try {
 file_put_contents($this->path, static::encode($hash, $options). ($options & self::JSON_PRETTY_PRINT ? "\n" : ''));
 break;
 } catch (\Exception $e) {
 if ($retries) {
 usleep(500000);
 continue;
 }

 throw $e;
 }
 }
 }








 public function validateSchema($schema = self::STRICT_SCHEMA)
 {
 $content = file_get_contents($this->path);
 $data = json_decode($content);

 if (null === $data && 'null' !== $content) {
 self::validateSyntax($content, $this->path);
 }

 $schemaFile = __DIR__ . '/../../../res/composer-schema.json';
 $schemaData = json_decode(file_get_contents($schemaFile));

 if ($schema === self::LAX_SCHEMA) {
 $schemaData->additionalProperties = true;
 $schemaData->required = array();
 }

 $validator = new Validator();
 $validator->check($data, $schemaData);



 if (!$validator->isValid()) {
 $errors = array();
 foreach ((array) $validator->getErrors() as $error) {
 $errors[] = ($error['property'] ? $error['property'].' : ' : '').$error['message'];
 }
 throw new JsonValidationException('"'.$this->path.'" does not match the expected JSON schema', $errors);
 }

 return true;
 }








 public static function encode($data, $options = 448)
 {
 if (PHP_VERSION_ID >= 50400) {
 $json = json_encode($data, $options);
 if (false === $json) {
 self::throwEncodeError(json_last_error());
 }


 if (PHP_VERSION_ID < 50428 || (PHP_VERSION_ID >= 50500 && PHP_VERSION_ID < 50512) || (defined('JSON_C_VERSION') && version_compare(phpversion('json'), '1.3.6', '<'))) {
 $json = preg_replace('/\[\s+\]/', '[]', $json);
 $json = preg_replace('/\{\s+\}/', '{}', $json);
 }

 return $json;
 }

 $json = json_encode($data);
 if (false === $json) {
 self::throwEncodeError(json_last_error());
 }

 $prettyPrint = (bool) ($options & self::JSON_PRETTY_PRINT);
 $unescapeUnicode = (bool) ($options & self::JSON_UNESCAPED_UNICODE);
 $unescapeSlashes = (bool) ($options & self::JSON_UNESCAPED_SLASHES);

 if (!$prettyPrint && !$unescapeUnicode && !$unescapeSlashes) {
 return $json;
 }

 $result = JsonFormatter::format($json, $unescapeUnicode, $unescapeSlashes);

 return $result;
 }







 private static function throwEncodeError($code)
 {
 switch ($code) {
 case JSON_ERROR_DEPTH:
 $msg = 'Maximum stack depth exceeded';
 break;
 case JSON_ERROR_STATE_MISMATCH:
 $msg = 'Underflow or the modes mismatch';
 break;
 case JSON_ERROR_CTRL_CHAR:
 $msg = 'Unexpected control character found';
 break;
 case JSON_ERROR_UTF8:
 $msg = 'Malformed UTF-8 characters, possibly incorrectly encoded';
 break;
 default:
 $msg = 'Unknown error';
 }

 throw new \RuntimeException('JSON encoding failed: '.$msg);
 }









 public static function parseJson($json, $file = null)
 {
 if (null === $json) {
 return;
 }
 $data = json_decode($json, true);
 if (null === $data && JSON_ERROR_NONE !== json_last_error()) {
 self::validateSyntax($json, $file);
 }

 return $data;
 }











 protected static function validateSyntax($json, $file = null)
 {
 $parser = new JsonParser();
 $result = $parser->lint($json);
 if (null === $result) {
 if (defined('JSON_ERROR_UTF8') && JSON_ERROR_UTF8 === json_last_error()) {
 throw new \UnexpectedValueException('"'.$file.'" is not UTF-8, could not parse as JSON');
 }

 return true;
 }

 throw new ParsingException('"'.$file.'" does not contain valid JSON'."\n".$result->getMessage(), $result->getDetails());
 }
 }
 <?php











 namespace Composer\Json;









 class JsonFormatter
 {













 public static function format($json, $unescapeUnicode, $unescapeSlashes)
 {
 $result = '';
 $pos = 0;
 $strLen = strlen($json);
 $indentStr = '    ';
 $newLine = "\n";
 $outOfQuotes = true;
 $buffer = '';
 $noescape = true;

 for ($i = 0; $i < $strLen; $i++) {

 $char = substr($json, $i, 1);


 if ('"' === $char && $noescape) {
 $outOfQuotes = !$outOfQuotes;
 }

 if (!$outOfQuotes) {
 $buffer .= $char;
 $noescape = '\\' === $char ? !$noescape : true;
 continue;
 } elseif ('' !== $buffer) {
 if ($unescapeSlashes) {
 $buffer = str_replace('\\/', '/', $buffer);
 }

 if ($unescapeUnicode && function_exists('mb_convert_encoding')) {

 $buffer = preg_replace_callback('/(\\\\+)u([0-9a-f]{4})/i', function ($match) {
 $l = strlen($match[1]);

 if ($l % 2) {
 return str_repeat('\\', $l - 1) . mb_convert_encoding(
 pack('H*', $match[2]),
 'UTF-8',
 'UCS-2BE'
 );
 }

 return $match[0];
 }, $buffer);
 }

 $result .= $buffer.$char;
 $buffer = '';
 continue;
 }

 if (':' === $char) {

 $char .= ' ';
 } elseif (('}' === $char || ']' === $char)) {
 $pos--;
 $prevChar = substr($json, $i - 1, 1);

 if ('{' !== $prevChar && '[' !== $prevChar) {

 
 $result .= $newLine;
 for ($j = 0; $j < $pos; $j++) {
 $result .= $indentStr;
 }
 } else {

 $result = rtrim($result);
 }
 }

 $result .= $char;


 
 if (',' === $char || '{' === $char || '[' === $char) {
 $result .= $newLine;

 if ('{' === $char || '[' === $char) {
 $pos++;
 }

 for ($j = 0; $j < $pos; $j++) {
 $result .= $indentStr;
 }
 }
 }

 return $result;
 }
 }
 <?php











 namespace Composer\Json;

 use Composer\Repository\PlatformRepository;




 class JsonManipulator
 {
 private static $RECURSE_BLOCKS;
 private static $RECURSE_ARRAYS;
 private static $JSON_VALUE;
 private static $JSON_STRING;

 private $contents;
 private $newline;
 private $indent;

 public function __construct($contents)
 {
 if (!self::$RECURSE_BLOCKS) {
 self::$RECURSE_BLOCKS = '(?:[^{}]*|\{(?:[^{}]*|\{(?:[^{}]*|\{(?:[^{}]*|\{[^{}]*\})*\})*\})*\})*';
 self::$RECURSE_ARRAYS = '(?:[^\]]*|\[(?:[^\]]*|\[(?:[^\]]*|\[(?:[^\]]*|\[[^\]]*\])*\])*\])*\]|'.self::$RECURSE_BLOCKS.')*';
 self::$JSON_STRING = '"(?:[^\0-\x09\x0a-\x1f\\\\"]+|\\\\["bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4})*"';
 self::$JSON_VALUE = '(?:[0-9.]+|null|true|false|'.self::$JSON_STRING.'|\['.self::$RECURSE_ARRAYS.'\]|\{'.self::$RECURSE_BLOCKS.'\})';
 }

 $contents = trim($contents);
 if ($contents === '') {
 $contents = '{}';
 }
 if (!$this->pregMatch('#^\{(.*)\}$#s', $contents)) {
 throw new \InvalidArgumentException('The json file must be an object ({})');
 }
 $this->newline = false !== strpos($contents, "\r\n") ? "\r\n" : "\n";
 $this->contents = $contents === '{}' ? '{' . $this->newline . '}' : $contents;
 $this->detectIndenting();
 }

 public function getContents()
 {
 return $this->contents . $this->newline;
 }

 public function addLink($type, $package, $constraint, $sortPackages = false)
 {
 $decoded = JsonFile::parseJson($this->contents);


 if (!isset($decoded[$type])) {
 return $this->addMainKey($type, array($package => $constraint));
 }

 $regex = '{^(\s*\{\s*(?:'.self::$JSON_STRING.'\s*:\s*'.self::$JSON_VALUE.'\s*,\s*)*?)'.
 '('.preg_quote(JsonFile::encode($type)).'\s*:\s*)('.self::$JSON_VALUE.')(.*)}s';
 if (!$this->pregMatch($regex, $this->contents, $matches)) {
 return false;
 }

 $links = $matches[3];

 if (isset($decoded[$type][$package])) {

 $packageRegex = str_replace('/', '\\\\?/', preg_quote($package));

 $links = preg_replace('{"'.$packageRegex.'"(\s*:\s*)'.self::$JSON_STRING.'}i', addcslashes(JsonFile::encode($package).'${1}"'.$constraint.'"', '\\'), $links);
 } else {
 if ($this->pregMatch('#^\s*\{\s*\S+.*?(\s*\}\s*)$#s', $links, $match)) {

 $links = preg_replace(
 '{'.preg_quote($match[1]).'$}',
 addcslashes(',' . $this->newline . $this->indent . $this->indent . JsonFile::encode($package).': '.JsonFile::encode($constraint) . $match[1], '\\'),
 $links
 );
 } else {

 $links = '{' . $this->newline .
 $this->indent . $this->indent . JsonFile::encode($package).': '.JsonFile::encode($constraint) . $this->newline .
 $this->indent . '}';
 }
 }

 if (true === $sortPackages) {
 $requirements = json_decode($links, true);
 $this->sortPackages($requirements);
 $links = $this->format($requirements);
 }

 $this->contents = $matches[1] . $matches[2] . $links . $matches[4];

 return true;
 }








 private function sortPackages(array &$packages = array())
 {
 $prefix = function ($requirement) {
 if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $requirement)) {
 return preg_replace(
 array(
 '/^php/',
 '/^hhvm/',
 '/^ext/',
 '/^lib/',
 '/^\D/',
 ),
 array(
 '0-$0',
 '1-$0',
 '2-$0',
 '3-$0',
 '4-$0',
 ),
 $requirement
 );
 }

 return '5-'.$requirement;
 };

 uksort($packages, function ($a, $b) use ($prefix) {
 return strnatcmp($prefix($a), $prefix($b));
 });
 }

 public function addRepository($name, $config)
 {
 return $this->addSubNode('repositories', $name, $config);
 }

 public function removeRepository($name)
 {
 return $this->removeSubNode('repositories', $name);
 }

 public function addConfigSetting($name, $value)
 {
 return $this->addSubNode('config', $name, $value);
 }

 public function removeConfigSetting($name)
 {
 return $this->removeSubNode('config', $name);
 }

 public function addSubNode($mainNode, $name, $value)
 {
 $decoded = JsonFile::parseJson($this->contents);

 $subName = null;
 if (in_array($mainNode, array('config', 'repositories')) && false !== strpos($name, '.')) {
 list($name, $subName) = explode('.', $name, 2);
 }


 if (!isset($decoded[$mainNode])) {
 if ($subName !== null) {
 $this->addMainKey($mainNode, array($name => array($subName => $value)));
 } else {
 $this->addMainKey($mainNode, array($name => $value));
 }

 return true;
 }


 $nodeRegex = '{^(\s*\{\s*(?:'.self::$JSON_STRING.'\s*:\s*'.self::$JSON_VALUE.'\s*,\s*)*?)'.
 '('.preg_quote(JsonFile::encode($mainNode)).'\s*:\s*\{)('.self::$RECURSE_BLOCKS.')(\})(.*)}s';
 try {
 if (!$this->pregMatch($nodeRegex, $this->contents, $match)) {
 return false;
 }
 } catch (\RuntimeException $e) {
 if ($e->getCode() === PREG_BACKTRACK_LIMIT_ERROR) {
 return false;
 }
 throw $e;
 }

 $children = $match[3];


 if (!@json_decode('{'.$children.'}')) {
 return false;
 }

 $that = $this;


 if ($this->pregMatch('{("'.preg_quote($name).'"\s*:\s*)('.self::$JSON_VALUE.')(,?)}', $children, $matches)) {
 $children = preg_replace_callback('{("'.preg_quote($name).'"\s*:\s*)('.self::$JSON_VALUE.')(,?)}', function ($matches) use ($name, $subName, $value, $that) {
 if ($subName !== null) {
 $curVal = json_decode($matches[2], true);
 $curVal[$subName] = $value;
 $value = $curVal;
 }

 return $matches[1] . $that->format($value, 1) . $matches[3];
 }, $children);
 } elseif ($this->pregMatch('#[^\s](\s*)$#', $children, $match)) {
 if ($subName !== null) {
 $value = array($subName => $value);
 }


 $children = preg_replace(
 '#'.$match[1].'$#',
 addcslashes(',' . $this->newline . $this->indent . $this->indent . JsonFile::encode($name).': '.$this->format($value, 1) . $match[1], '\\'),
 $children
 );
 } else {
 if ($subName !== null) {
 $value = array($subName => $value);
 }


 $children = $this->newline . $this->indent . $this->indent . JsonFile::encode($name).': '.$this->format($value, 1) . $children;
 }

 $this->contents = preg_replace($nodeRegex, addcslashes('${1}${2}'.$children.'${4}${5}', '\\'), $this->contents);

 return true;
 }

 public function removeSubNode($mainNode, $name)
 {
 $decoded = JsonFile::parseJson($this->contents);


 if (empty($decoded[$mainNode])) {
 return true;
 }


 $nodeRegex = '{^(\s*\{\s*(?:'.self::$JSON_STRING.'\s*:\s*'.self::$JSON_VALUE.'\s*,\s*)*?)'.
 '('.preg_quote(JsonFile::encode($mainNode)).'\s*:\s*\{)('.self::$RECURSE_BLOCKS.')(\})(.*)}s';
 try {
 if (!$this->pregMatch($nodeRegex, $this->contents, $match)) {
 return false;
 }
 } catch (\RuntimeException $e) {
 if ($e->getCode() === PREG_BACKTRACK_LIMIT_ERROR) {
 return false;
 }
 throw $e;
 }

 $children = $match[3];


 if (!@json_decode('{'.$children.'}', true)) {
 return false;
 }

 $subName = null;
 if (in_array($mainNode, array('config', 'repositories')) && false !== strpos($name, '.')) {
 list($name, $subName) = explode('.', $name, 2);
 }


 if (!isset($decoded[$mainNode][$name]) || ($subName && !isset($decoded[$mainNode][$name][$subName]))) {
 return true;
 }


 if ($this->pregMatch('{"'.preg_quote($name).'"\s*:}i', $children)) {

 if (preg_match_all('{"'.preg_quote($name).'"\s*:\s*(?:'.self::$JSON_VALUE.')}', $children, $matches)) {
 $bestMatch = '';
 foreach ($matches[0] as $match) {
 if (strlen($bestMatch) < strlen($match)) {
 $bestMatch = $match;
 }
 }
 $childrenClean = preg_replace('{,\s*'.preg_quote($bestMatch).'}i', '', $children, -1, $count);
 if (1 !== $count) {
 $childrenClean = preg_replace('{'.preg_quote($bestMatch).'\s*,?\s*}i', '', $childrenClean, -1, $count);
 if (1 !== $count) {
 return false;
 }
 }
 }
 } else {
 $childrenClean = $children;
 }


 if (!trim($childrenClean)) {
 $this->contents = preg_replace($nodeRegex, '$1$2'.$this->newline.$this->indent.'$4$5', $this->contents);


 if ($subName !== null) {
 $curVal = json_decode('{'.$children.'}', true);
 unset($curVal[$name][$subName]);
 $this->addSubNode($mainNode, $name, $curVal[$name]);
 }

 return true;
 }

 $that = $this;
 $this->contents = preg_replace_callback($nodeRegex, function ($matches) use ($that, $name, $subName, $childrenClean) {
 if ($subName !== null) {
 $curVal = json_decode('{'.$matches[3].'}', true);
 unset($curVal[$name][$subName]);
 $childrenClean = substr($that->format($curVal, 0), 1, -1);
 }

 return $matches[1] . $matches[2] . $childrenClean . $matches[4] . $matches[5];
 }, $this->contents);

 return true;
 }

 public function addMainKey($key, $content)
 {
 $decoded = JsonFile::parseJson($this->contents);
 $content = $this->format($content);


 $regex = '{^(\s*\{\s*(?:'.self::$JSON_STRING.'\s*:\s*'.self::$JSON_VALUE.'\s*,\s*)*?)'.
 '('.preg_quote(JsonFile::encode($key)).'\s*:\s*'.self::$JSON_VALUE.')(.*)}s';
 if (isset($decoded[$key]) && $this->pregMatch($regex, $this->contents, $matches)) {

 if (!@json_decode('{'.$matches[2].'}')) {
 return false;
 }

 $this->contents = $matches[1] . JsonFile::encode($key).': '.$content . $matches[3];

 return true;
 }


 if ($this->pregMatch('#[^{\s](\s*)\}$#', $this->contents, $match)) {
 $this->contents = preg_replace(
 '#'.$match[1].'\}$#',
 addcslashes(',' . $this->newline . $this->indent . JsonFile::encode($key). ': '. $content . $this->newline . '}', '\\'),
 $this->contents
 );

 return true;
 }


 $this->contents = preg_replace(
 '#\}$#',
 addcslashes($this->indent . JsonFile::encode($key). ': '.$content . $this->newline . '}', '\\'),
 $this->contents
 );

 return true;
 }

 public function format($data, $depth = 0)
 {
 if (is_array($data)) {
 reset($data);

 if (is_numeric(key($data))) {
 foreach ($data as $key => $val) {
 $data[$key] = $this->format($val, $depth + 1);
 }

 return '['.implode(', ', $data).']';
 }

 $out = '{' . $this->newline;
 $elems = array();
 foreach ($data as $key => $val) {
 $elems[] = str_repeat($this->indent, $depth + 2) . JsonFile::encode($key). ': '.$this->format($val, $depth + 1);
 }

 return $out . implode(','.$this->newline, $elems) . $this->newline . str_repeat($this->indent, $depth + 1) . '}';
 }

 return JsonFile::encode($data);
 }

 protected function detectIndenting()
 {
 if ($this->pregMatch('{^([ \t]+)"}m', $this->contents, $match)) {
 $this->indent = $match[1];
 } else {
 $this->indent = '    ';
 }
 }

 protected function pregMatch($re, $str, &$matches = array())
 {
 $count = preg_match($re, $str, $matches);

 if ($count === false) {
 switch (preg_last_error()) {
 case PREG_NO_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_NO_ERROR', PREG_NO_ERROR);
 case PREG_INTERNAL_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_INTERNAL_ERROR', PREG_INTERNAL_ERROR);
 case PREG_BACKTRACK_LIMIT_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_BACKTRACK_LIMIT_ERROR', PREG_BACKTRACK_LIMIT_ERROR);
 case PREG_RECURSION_LIMIT_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_RECURSION_LIMIT_ERROR', PREG_RECURSION_LIMIT_ERROR);
 case PREG_BAD_UTF8_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_BAD_UTF8_ERROR', PREG_BAD_UTF8_ERROR);
 case PREG_BAD_UTF8_OFFSET_ERROR:
 throw new \RuntimeException('Failed to execute regex: PREG_BAD_UTF8_OFFSET_ERROR', PREG_BAD_UTF8_OFFSET_ERROR);
 default:
 throw new \RuntimeException('Failed to execute regex: Unknown error');
 }
 }

 return $count;
 }
 }
 <?php











 namespace Composer\Json;

 use Exception;




 class JsonValidationException extends Exception
 {
 protected $errors;

 public function __construct($message, $errors = array(), Exception $previous = null)
 {
 $this->errors = $errors;
 parent::__construct($message, 0, $previous);
 }

 public function getErrors()
 {
 return $this->errors;
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Package\Version\VersionParser;




 class AliasPackage extends BasePackage implements CompletePackageInterface
 {
 protected $version;
 protected $prettyVersion;
 protected $dev;
 protected $aliasOf;
 protected $rootPackageAlias = false;
 protected $stability;

 protected $requires;
 protected $devRequires;
 protected $conflicts;
 protected $provides;
 protected $replaces;
 protected $recommends;
 protected $suggests;








 public function __construct(PackageInterface $aliasOf, $version, $prettyVersion)
 {
 parent::__construct($aliasOf->getName());

 $this->version = $version;
 $this->prettyVersion = $prettyVersion;
 $this->aliasOf = $aliasOf;
 $this->stability = VersionParser::parseStability($version);
 $this->dev = $this->stability === 'dev';

 foreach (array('requires', 'devRequires', 'conflicts', 'provides', 'replaces') as $type) {
 $links = $aliasOf->{'get' . ucfirst($type)}();
 $this->$type = $this->replaceSelfVersionDependencies($links, $type);
 }
 }




 public function getAliasOf()
 {
 return $this->aliasOf;
 }




 public function getVersion()
 {
 return $this->version;
 }




 public function getStability()
 {
 return $this->stability;
 }




 public function getPrettyVersion()
 {
 return $this->prettyVersion;
 }




 public function isDev()
 {
 return $this->dev;
 }




 public function getRequires()
 {
 return $this->requires;
 }




 public function getConflicts()
 {
 return $this->conflicts;
 }




 public function getProvides()
 {
 return $this->provides;
 }




 public function getReplaces()
 {
 return $this->replaces;
 }




 public function getDevRequires()
 {
 return $this->devRequires;
 }










 public function setRootPackageAlias($value)
 {
 return $this->rootPackageAlias = $value;
 }





 public function isRootPackageAlias()
 {
 return $this->rootPackageAlias;
 }







 protected function replaceSelfVersionDependencies(array $links, $linkType)
 {
 if (in_array($linkType, array('conflicts', 'provides', 'replaces'), true)) {
 $newLinks = array();
 foreach ($links as $link) {

 if ('self.version' === $link->getPrettyConstraint()) {
 $newLinks[] = new Link($link->getSource(), $link->getTarget(), new VersionConstraint('=', $this->version), $linkType, $this->prettyVersion);
 }
 }
 $links = array_merge($links, $newLinks);
 } else {
 foreach ($links as $index => $link) {
 if ('self.version' === $link->getPrettyConstraint()) {
 $links[$index] = new Link($link->getSource(), $link->getTarget(), new VersionConstraint('=', $this->version), $linkType, $this->prettyVersion);
 }
 }
 }

 return $links;
 }





 public function getType()
 {
 return $this->aliasOf->getType();
 }
 public function getTargetDir()
 {
 return $this->aliasOf->getTargetDir();
 }
 public function getExtra()
 {
 return $this->aliasOf->getExtra();
 }
 public function setInstallationSource($type)
 {
 $this->aliasOf->setInstallationSource($type);
 }
 public function getInstallationSource()
 {
 return $this->aliasOf->getInstallationSource();
 }
 public function getSourceType()
 {
 return $this->aliasOf->getSourceType();
 }
 public function getSourceUrl()
 {
 return $this->aliasOf->getSourceUrl();
 }
 public function getSourceUrls()
 {
 return $this->aliasOf->getSourceUrls();
 }
 public function getSourceReference()
 {
 return $this->aliasOf->getSourceReference();
 }
 public function setSourceReference($reference)
 {
 return $this->aliasOf->setSourceReference($reference);
 }
 public function setSourceMirrors($mirrors)
 {
 return $this->aliasOf->setSourceMirrors($mirrors);
 }
 public function getSourceMirrors()
 {
 return $this->aliasOf->getSourceMirrors();
 }
 public function getDistType()
 {
 return $this->aliasOf->getDistType();
 }
 public function getDistUrl()
 {
 return $this->aliasOf->getDistUrl();
 }
 public function getDistUrls()
 {
 return $this->aliasOf->getDistUrls();
 }
 public function getDistReference()
 {
 return $this->aliasOf->getDistReference();
 }
 public function setDistReference($reference)
 {
 return $this->aliasOf->setDistReference($reference);
 }
 public function getDistSha1Checksum()
 {
 return $this->aliasOf->getDistSha1Checksum();
 }
 public function setTransportOptions(array $options)
 {
 return $this->aliasOf->setTransportOptions($options);
 }
 public function getTransportOptions()
 {
 return $this->aliasOf->getTransportOptions();
 }
 public function setDistMirrors($mirrors)
 {
 return $this->aliasOf->setDistMirrors($mirrors);
 }
 public function getDistMirrors()
 {
 return $this->aliasOf->getDistMirrors();
 }
 public function getScripts()
 {
 return $this->aliasOf->getScripts();
 }
 public function getLicense()
 {
 return $this->aliasOf->getLicense();
 }
 public function getAutoload()
 {
 return $this->aliasOf->getAutoload();
 }
 public function getDevAutoload()
 {
 return $this->aliasOf->getDevAutoload();
 }
 public function getIncludePaths()
 {
 return $this->aliasOf->getIncludePaths();
 }
 public function getRepositories()
 {
 return $this->aliasOf->getRepositories();
 }
 public function getReleaseDate()
 {
 return $this->aliasOf->getReleaseDate();
 }
 public function getBinaries()
 {
 return $this->aliasOf->getBinaries();
 }
 public function getKeywords()
 {
 return $this->aliasOf->getKeywords();
 }
 public function getDescription()
 {
 return $this->aliasOf->getDescription();
 }
 public function getHomepage()
 {
 return $this->aliasOf->getHomepage();
 }
 public function getSuggests()
 {
 return $this->aliasOf->getSuggests();
 }
 public function getAuthors()
 {
 return $this->aliasOf->getAuthors();
 }
 public function getSupport()
 {
 return $this->aliasOf->getSupport();
 }
 public function getNotificationUrl()
 {
 return $this->aliasOf->getNotificationUrl();
 }
 public function getArchiveExcludes()
 {
 return $this->aliasOf->getArchiveExcludes();
 }
 public function isAbandoned()
 {
 return $this->aliasOf->isAbandoned();
 }
 public function getReplacementPackage()
 {
 return $this->aliasOf->getReplacementPackage();
 }
 public function __toString()
 {
 return parent::__toString().' (alias of '.$this->aliasOf->getVersion().')';
 }
 }
 <?php











 namespace Composer\Package\Archiver;

 use Composer\Util\Filesystem;
 use Symfony\Component\Finder\Finder;









 class ArchivableFilesFinder extends \FilterIterator
 {



 protected $finder;







 public function __construct($sources, array $excludes)
 {
 $fs = new Filesystem();

 $sources = $fs->normalizePath($sources);

 $filters = array(
 new HgExcludeFilter($sources),
 new GitExcludeFilter($sources),
 new ComposerExcludeFilter($sources, $excludes),
 );

 $this->finder = new Finder();

 $filter = function (\SplFileInfo $file) use ($sources, $filters, $fs) {
 if ($file->isLink() && strpos($file->getLinkTarget(), $sources) !== 0) {
 return false;
 }

 $relativePath = preg_replace(
 '#^'.preg_quote($sources, '#').'#',
 '',
 $fs->normalizePath($file->getRealPath())
 );

 $exclude = false;
 foreach ($filters as $filter) {
 $exclude = $filter->filter($relativePath, $exclude);
 }

 return !$exclude;
 };

 if (method_exists($filter, 'bindTo')) {
 $filter = $filter->bindTo(null);
 }

 $this->finder
 ->in($sources)
 ->filter($filter)
 ->ignoreVCS(true)
 ->ignoreDotFiles(false);

 parent::__construct($this->finder->getIterator());
 }

 public function accept()
 {
 return !$this->getInnerIterator()->current()->isDir();
 }
 }
 <?php











 namespace Composer\Package\Archiver;

 use Composer\Downloader\DownloadManager;
 use Composer\Package\PackageInterface;
 use Composer\Package\RootPackageInterface;
 use Composer\Util\Filesystem;
 use Composer\Json\JsonFile;





 class ArchiveManager
 {
 protected $downloadManager;

 protected $archivers = array();




 protected $overwriteFiles = true;




 public function __construct(DownloadManager $downloadManager)
 {
 $this->downloadManager = $downloadManager;
 }




 public function addArchiver(ArchiverInterface $archiver)
 {
 $this->archivers[] = $archiver;
 }








 public function setOverwriteFiles($overwriteFiles)
 {
 $this->overwriteFiles = $overwriteFiles;

 return $this;
 }








 public function getPackageFilename(PackageInterface $package)
 {
 $nameParts = array(preg_replace('#[^a-z0-9-_]#i', '-', $package->getName()));

 if (preg_match('{^[a-f0-9]{40}$}', $package->getDistReference())) {
 $nameParts = array_merge($nameParts, array($package->getDistReference(), $package->getDistType()));
 } else {
 $nameParts = array_merge($nameParts, array($package->getPrettyVersion(), $package->getDistReference()));
 }

 if ($package->getSourceReference()) {
 $nameParts[] = substr(sha1($package->getSourceReference()), 0, 6);
 }

 $name = implode('-', array_filter($nameParts, function ($p) {
 return !empty($p);
 }));

 return str_replace('/', '-', $name);
 }











 public function archive(PackageInterface $package, $format, $targetDir)
 {
 if (empty($format)) {
 throw new \InvalidArgumentException('Format must be specified');
 }


 $usableArchiver = null;
 foreach ($this->archivers as $archiver) {
 if ($archiver->supports($format, $package->getSourceType())) {
 $usableArchiver = $archiver;
 break;
 }
 }


 if (null === $usableArchiver) {
 throw new \RuntimeException(sprintf('No archiver found to support %s format', $format));
 }

 $filesystem = new Filesystem();
 $packageName = $this->getPackageFilename($package);


 $filesystem->ensureDirectoryExists($targetDir);
 $target = realpath($targetDir).'/'.$packageName.'.'.$format;
 $filesystem->ensureDirectoryExists(dirname($target));

 if (!$this->overwriteFiles && file_exists($target)) {
 return $target;
 }

 if ($package instanceof RootPackageInterface) {
 $sourcePath = realpath('.');
 } else {

 $sourcePath = sys_get_temp_dir().'/composer_archive'.uniqid();
 $filesystem->ensureDirectoryExists($sourcePath);


 $this->downloadManager->download($package, $sourcePath);


 if (file_exists($composerJsonPath = $sourcePath.'/composer.json')) {
 $jsonFile = new JsonFile($composerJsonPath);
 $jsonData = $jsonFile->read();
 if (!empty($jsonData['archive']['exclude'])) {
 $package->setArchiveExcludes($jsonData['archive']['exclude']);
 }
 }
 }


 $tempTarget = sys_get_temp_dir().'/composer_archive'.uniqid().'.'.$format;
 $filesystem->ensureDirectoryExists(dirname($tempTarget));

 $archivePath = $usableArchiver->archive($sourcePath, $tempTarget, $format, $package->getArchiveExcludes());
 rename($archivePath, $target);


 if (!$package instanceof RootPackageInterface) {
 $filesystem->removeDirectory($sourcePath);
 }
 $filesystem->remove($tempTarget);

 return $target;
 }
 }
 <?php











 namespace Composer\Package\Archiver;






 interface ArchiverInterface
 {










 public function archive($sources, $target, $format, array $excludes = array());









 public function supports($format, $sourceType);
 }
 <?php











 namespace Composer\Package\Archiver;

 use Symfony\Component\Finder;




 abstract class BaseExcludeFilter
 {



 protected $sourcePath;




 protected $excludePatterns;




 public function __construct($sourcePath)
 {
 $this->sourcePath = $sourcePath;
 $this->excludePatterns = array();
 }











 public function filter($relativePath, $exclude)
 {
 foreach ($this->excludePatterns as $patternData) {
 list($pattern, $negate, $stripLeadingSlash) = $patternData;

 if ($stripLeadingSlash) {
 $path = substr($relativePath, 1);
 } else {
 $path = $relativePath;
 }

 if (preg_match($pattern, $path)) {
 $exclude = !$negate;
 }
 }

 return $exclude;
 }









 protected function parseLines(array $lines, $lineParser)
 {
 return array_filter(
 array_map(
 function ($line) use ($lineParser) {
 $line = trim($line);

 if (!$line || 0 === strpos($line, '#')) {
 return;
 }

 return call_user_func($lineParser, $line);
 },
 $lines
 ),
 function ($pattern) {
 return $pattern !== null;
 }
 );
 }








 protected function generatePatterns($rules)
 {
 $patterns = array();
 foreach ($rules as $rule) {
 $patterns[] = $this->generatePattern($rule);
 }

 return $patterns;
 }








 protected function generatePattern($rule)
 {
 $negate = false;
 $pattern = '{';

 if (strlen($rule) && $rule[0] === '!') {
 $negate = true;
 $rule = substr($rule, 1);
 }

 if (strlen($rule) && $rule[0] === '/') {
 $pattern .= '^/';
 $rule = substr($rule, 1);
 } elseif (strlen($rule) - 1 === strpos($rule, '/')) {
 $pattern .= '/';
 $rule = substr($rule, 0, -1);
 } elseif (false === strpos($rule, '/')) {
 $pattern .= '/';
 }


 $pattern .= substr(Finder\Glob::toRegex($rule), 2, -2) . '(?=$|/)';

 return array($pattern . '}', $negate, false);
 }
 }
 <?php











 namespace Composer\Package\Archiver;






 class ComposerExcludeFilter extends BaseExcludeFilter
 {




 public function __construct($sourcePath, array $excludeRules)
 {
 parent::__construct($sourcePath);
 $this->excludePatterns = $this->generatePatterns($excludeRules);
 }
 }
 <?php











 namespace Composer\Package\Archiver;








 class GitExcludeFilter extends BaseExcludeFilter
 {





 public function __construct($sourcePath)
 {
 parent::__construct($sourcePath);

 if (file_exists($sourcePath.'/.gitignore')) {
 $this->excludePatterns = $this->parseLines(
 file($sourcePath.'/.gitignore'),
 array($this, 'parseGitIgnoreLine')
 );
 }
 if (file_exists($sourcePath.'/.gitattributes')) {
 $this->excludePatterns = array_merge(
 $this->excludePatterns,
 $this->parseLines(
 file($sourcePath.'/.gitattributes'),
 array($this, 'parseGitAttributesLine')
 ));
 }
 }








 public function parseGitIgnoreLine($line)
 {
 return $this->generatePattern($line);
 }








 public function parseGitAttributesLine($line)
 {
 $parts = preg_split('#\s+#', $line);

 if (count($parts) != 2) {
 return null;
 }

 if ($parts[1] === 'export-ignore') {
 return $this->generatePattern($parts[0]);
 }
 }
 }
 <?php











 namespace Composer\Package\Archiver;

 use Symfony\Component\Finder;






 class HgExcludeFilter extends BaseExcludeFilter
 {
 const HG_IGNORE_REGEX = 1;
 const HG_IGNORE_GLOB = 2;





 protected $patternMode;






 public function __construct($sourcePath)
 {
 parent::__construct($sourcePath);

 $this->patternMode = self::HG_IGNORE_REGEX;

 if (file_exists($sourcePath.'/.hgignore')) {
 $this->excludePatterns = $this->parseLines(
 file($sourcePath.'/.hgignore'),
 array($this, 'parseHgIgnoreLine')
 );
 }
 }








 public function parseHgIgnoreLine($line)
 {
 if (preg_match('#^syntax\s*:\s*(glob|regexp)$#', $line, $matches)) {
 if ($matches[1] === 'glob') {
 $this->patternMode = self::HG_IGNORE_GLOB;
 } else {
 $this->patternMode = self::HG_IGNORE_REGEX;
 }

 return null;
 }

 if ($this->patternMode == self::HG_IGNORE_GLOB) {
 return $this->patternFromGlob($line);
 } else {
 return $this->patternFromRegex($line);
 }
 }








 protected function patternFromGlob($line)
 {
 $pattern = '#'.substr(Finder\Glob::toRegex($line), 2, -1).'#';
 $pattern = str_replace('[^/]*', '.*', $pattern);

 return array($pattern, false, true);
 }








 public function patternFromRegex($line)
 {

 $pattern = '#'.preg_replace('/((?:\\\\\\\\)*)(\\\\?)#/', '\1\2\2\\#', $line).'#';

 return array($pattern, false, true);
 }
 }
 <?php











 namespace Composer\Package\Archiver;






 class PharArchiver implements ArchiverInterface
 {
 protected static $formats = array(
 'zip' => \Phar::ZIP,
 'tar' => \Phar::TAR,
 );




 public function archive($sources, $target, $format, array $excludes = array())
 {
 $sources = realpath($sources);


 if (file_exists($target)) {
 unlink($target);
 }

 try {
 $phar = new \PharData($target, null, null, static::$formats[$format]);
 $files = new ArchivableFilesFinder($sources, $excludes);
 $phar->buildFromIterator($files, $sources);

 return $target;
 } catch (\UnexpectedValueException $e) {
 $message = sprintf("Could not create archive '%s' from '%s': %s",
 $target,
 $sources,
 $e->getMessage()
 );

 throw new \RuntimeException($message, $e->getCode(), $e);
 }
 }




 public function supports($format, $sourceType)
 {
 return isset(static::$formats[$format]);
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Repository\RepositoryInterface;
 use Composer\Repository\PlatformRepository;






 abstract class BasePackage implements PackageInterface
 {
 public static $supportedLinkTypes = array(
 'require' => array('description' => 'requires', 'method' => 'requires'),
 'conflict' => array('description' => 'conflicts', 'method' => 'conflicts'),
 'provide' => array('description' => 'provides', 'method' => 'provides'),
 'replace' => array('description' => 'replaces', 'method' => 'replaces'),
 'require-dev' => array('description' => 'requires (for development)', 'method' => 'devRequires'),
 );

 const STABILITY_STABLE = 0;
 const STABILITY_RC = 5;
 const STABILITY_BETA = 10;
 const STABILITY_ALPHA = 15;
 const STABILITY_DEV = 20;

 public static $stabilities = array(
 'stable' => self::STABILITY_STABLE,
 'RC' => self::STABILITY_RC,
 'beta' => self::STABILITY_BETA,
 'alpha' => self::STABILITY_ALPHA,
 'dev' => self::STABILITY_DEV,
 );





 public $id;

 protected $name;
 protected $prettyName;

 protected $repository;
 protected $transportOptions;






 public function __construct($name)
 {
 $this->prettyName = $name;
 $this->name = strtolower($name);
 $this->id = -1;
 $this->transportOptions = array();
 }




 public function getName()
 {
 return $this->name;
 }




 public function getPrettyName()
 {
 return $this->prettyName;
 }




 public function getNames()
 {
 $names = array(
 $this->getName() => true,
 );

 foreach ($this->getProvides() as $link) {
 $names[$link->getTarget()] = true;
 }

 foreach ($this->getReplaces() as $link) {
 $names[$link->getTarget()] = true;
 }

 return array_keys($names);
 }




 public function setId($id)
 {
 $this->id = $id;
 }




 public function getId()
 {
 return $this->id;
 }




 public function setRepository(RepositoryInterface $repository)
 {
 if ($this->repository && $repository !== $this->repository) {
 throw new \LogicException('A package can only be added to one repository');
 }
 $this->repository = $repository;
 }




 public function getRepository()
 {
 return $this->repository;
 }




 public function getTransportOptions()
 {
 return $this->transportOptions;
 }






 public function setTransportOptions(array $options)
 {
 $this->transportOptions = $options;
 }






 public function isPlatform()
 {
 return $this->getRepository() instanceof PlatformRepository;
 }






 public function getUniqueName()
 {
 return $this->getName().'-'.$this->getVersion();
 }

 public function equals(PackageInterface $package)
 {
 $self = $this;
 if ($this instanceof AliasPackage) {
 $self = $this->getAliasOf();
 }
 if ($package instanceof AliasPackage) {
 $package = $package->getAliasOf();
 }

 return $package === $self;
 }






 public function __toString()
 {
 return $this->getUniqueName();
 }

 public function getPrettyString()
 {
 return $this->getPrettyName().' '.$this->getPrettyVersion();
 }




 public function getFullPrettyVersion($truncate = true)
 {
 if (!$this->isDev() || !in_array($this->getSourceType(), array('hg', 'git'))) {
 return $this->getPrettyVersion();
 }


 if ($truncate && strlen($this->getSourceReference()) === 40) {
 return $this->getPrettyVersion() . ' ' . substr($this->getSourceReference(), 0, 7);
 }

 return $this->getPrettyVersion() . ' ' . $this->getSourceReference();
 }

 public function __clone()
 {
 $this->repository = null;
 $this->id = -1;
 }
 }
 <?php











 namespace Composer\Package;






 class CompletePackage extends Package implements CompletePackageInterface
 {
 protected $repositories;
 protected $license = array();
 protected $keywords;
 protected $authors;
 protected $description;
 protected $homepage;
 protected $scripts = array();
 protected $support = array();
 protected $abandoned = false;




 public function setScripts(array $scripts)
 {
 $this->scripts = $scripts;
 }




 public function getScripts()
 {
 return $this->scripts;
 }






 public function setRepositories($repositories)
 {
 $this->repositories = $repositories;
 }




 public function getRepositories()
 {
 return $this->repositories;
 }






 public function setLicense(array $license)
 {
 $this->license = $license;
 }




 public function getLicense()
 {
 return $this->license;
 }






 public function setKeywords(array $keywords)
 {
 $this->keywords = $keywords;
 }




 public function getKeywords()
 {
 return $this->keywords;
 }






 public function setAuthors(array $authors)
 {
 $this->authors = $authors;
 }




 public function getAuthors()
 {
 return $this->authors;
 }






 public function setDescription($description)
 {
 $this->description = $description;
 }




 public function getDescription()
 {
 return $this->description;
 }






 public function setHomepage($homepage)
 {
 $this->homepage = $homepage;
 }




 public function getHomepage()
 {
 return $this->homepage;
 }






 public function setSupport(array $support)
 {
 $this->support = $support;
 }




 public function getSupport()
 {
 return $this->support;
 }




 public function isAbandoned()
 {
 return (boolean) $this->abandoned;
 }




 public function setAbandoned($abandoned)
 {
 $this->abandoned = $abandoned;
 }






 public function getReplacementPackage()
 {
 return is_string($this->abandoned) ? $this->abandoned : null;
 }
 }
 <?php











 namespace Composer\Package;






 interface CompletePackageInterface extends PackageInterface
 {





 public function getScripts();








 public function getRepositories();






 public function getLicense();






 public function getKeywords();






 public function getDescription();






 public function getHomepage();








 public function getAuthors();






 public function getSupport();






 public function isAbandoned();






 public function getReplacementPackage();
 }
 <?php











 namespace Composer\Package\Dumper;

 use Composer\Package\BasePackage;
 use Composer\Package\PackageInterface;
 use Composer\Package\CompletePackageInterface;
 use Composer\Package\RootPackageInterface;





 class ArrayDumper
 {
 public function dump(PackageInterface $package)
 {
 $keys = array(
 'binaries' => 'bin',
 'type',
 'extra',
 'installationSource' => 'installation-source',
 'autoload',
 'devAutoload' => 'autoload-dev',
 'notificationUrl' => 'notification-url',
 'includePaths' => 'include-path',
 );

 $data = array();
 $data['name'] = $package->getPrettyName();
 $data['version'] = $package->getPrettyVersion();
 $data['version_normalized'] = $package->getVersion();

 if ($package->getTargetDir()) {
 $data['target-dir'] = $package->getTargetDir();
 }

 if ($package->getSourceType()) {
 $data['source']['type'] = $package->getSourceType();
 $data['source']['url'] = $package->getSourceUrl();
 $data['source']['reference'] = $package->getSourceReference();
 if ($mirrors = $package->getSourceMirrors()) {
 $data['source']['mirrors'] = $mirrors;
 }
 }

 if ($package->getDistType()) {
 $data['dist']['type'] = $package->getDistType();
 $data['dist']['url'] = $package->getDistUrl();
 $data['dist']['reference'] = $package->getDistReference();
 $data['dist']['shasum'] = $package->getDistSha1Checksum();
 if ($mirrors = $package->getDistMirrors()) {
 $data['dist']['mirrors'] = $mirrors;
 }
 }

 if ($package->getArchiveExcludes()) {
 $data['archive']['exclude'] = $package->getArchiveExcludes();
 }

 foreach (BasePackage::$supportedLinkTypes as $type => $opts) {
 if ($links = $package->{'get'.ucfirst($opts['method'])}()) {
 foreach ($links as $link) {
 $data[$type][$link->getTarget()] = $link->getPrettyConstraint();
 }
 ksort($data[$type]);
 }
 }

 if ($packages = $package->getSuggests()) {
 ksort($packages);
 $data['suggest'] = $packages;
 }

 if ($package->getReleaseDate()) {
 $data['time'] = $package->getReleaseDate()->format('Y-m-d H:i:s');
 }

 $data = $this->dumpValues($package, $keys, $data);

 if ($package instanceof CompletePackageInterface) {
 $keys = array(
 'scripts',
 'license',
 'authors',
 'description',
 'homepage',
 'keywords',
 'repositories',
 'support',
 );

 $data = $this->dumpValues($package, $keys, $data);

 if (isset($data['keywords']) && is_array($data['keywords'])) {
 sort($data['keywords']);
 }

 if ($package->isAbandoned()) {
 $data['abandoned'] = $package->getReplacementPackage() ?: true;
 }
 }

 if ($package instanceof RootPackageInterface) {
 $minimumStability = $package->getMinimumStability();
 if ($minimumStability) {
 $data['minimum-stability'] = $minimumStability;
 }
 }

 if (count($package->getTransportOptions()) > 0) {
 $data['transport-options'] = $package->getTransportOptions();
 }

 return $data;
 }

 private function dumpValues(PackageInterface $package, array $keys, array $data)
 {
 foreach ($keys as $method => $key) {
 if (is_numeric($method)) {
 $method = $key;
 }

 $getter = 'get'.ucfirst($method);
 $value = $package->$getter();

 if (null !== $value && !(is_array($value) && 0 === count($value))) {
 $data[$key] = $value;
 }
 }

 return $data;
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Package\LinkConstraint\LinkConstraintInterface;






 class Link
 {



 protected $source;




 protected $target;




 protected $constraint;




 protected $description;




 protected $prettyConstraint;










 public function __construct($source, $target, LinkConstraintInterface $constraint = null, $description = 'relates to', $prettyConstraint = null)
 {
 $this->source = strtolower($source);
 $this->target = strtolower($target);
 $this->constraint = $constraint;
 $this->description = $description;
 $this->prettyConstraint = $prettyConstraint;
 }




 public function getSource()
 {
 return $this->source;
 }




 public function getTarget()
 {
 return $this->target;
 }




 public function getConstraint()
 {
 return $this->constraint;
 }





 public function getPrettyConstraint()
 {
 if (null === $this->prettyConstraint) {
 throw new \UnexpectedValueException(sprintf('Link %s has been misconfigured and had no prettyConstraint given.', $this));
 }

 return $this->prettyConstraint;
 }




 public function __toString()
 {
 return $this->source.' '.$this->description.' '.$this->target.' ('.$this->constraint.')';
 }





 public function getPrettyString(PackageInterface $sourcePackage)
 {
 return $sourcePackage->getPrettyString().' '.$this->description.' '.$this->target.' '.$this->constraint->getPrettyString().'';
 }
 }
 <?php











 namespace Composer\Package\LinkConstraint;






 class EmptyConstraint implements LinkConstraintInterface
 {
 protected $prettyString;

 public function matches(LinkConstraintInterface $provider)
 {
 return true;
 }

 public function setPrettyString($prettyString)
 {
 $this->prettyString = $prettyString;
 }

 public function getPrettyString()
 {
 if ($this->prettyString) {
 return $this->prettyString;
 }

 return $this->__toString();
 }

 public function __toString()
 {
 return '[]';
 }
 }
 <?php











 namespace Composer\Package\LinkConstraint;






 interface LinkConstraintInterface
 {
 public function matches(LinkConstraintInterface $provider);
 public function setPrettyString($prettyString);
 public function getPrettyString();
 public function __toString();
 }
 <?php











 namespace Composer\Package\LinkConstraint;







 class MultiConstraint implements LinkConstraintInterface
 {
 protected $constraints;
 protected $prettyString;
 protected $conjunctive;







 public function __construct(array $constraints, $conjunctive = true)
 {
 $this->constraints = $constraints;
 $this->conjunctive = $conjunctive;
 }

 public function matches(LinkConstraintInterface $provider)
 {
 if (false === $this->conjunctive) {
 foreach ($this->constraints as $constraint) {
 if ($constraint->matches($provider)) {
 return true;
 }
 }

 return false;
 }

 foreach ($this->constraints as $constraint) {
 if (!$constraint->matches($provider)) {
 return false;
 }
 }

 return true;
 }

 public function setPrettyString($prettyString)
 {
 $this->prettyString = $prettyString;
 }

 public function getPrettyString()
 {
 if ($this->prettyString) {
 return $this->prettyString;
 }

 return $this->__toString();
 }

 public function __toString()
 {
 $constraints = array();
 foreach ($this->constraints as $constraint) {
 $constraints[] = $constraint->__toString();
 }

 return '['.implode($this->conjunctive ? ' ' : ' || ', $constraints).']';
 }
 }
 <?php











 namespace Composer\Package\LinkConstraint;






 abstract class SpecificConstraint implements LinkConstraintInterface
 {
 protected $prettyString;

 public function matches(LinkConstraintInterface $provider)
 {
 if ($provider instanceof MultiConstraint) {

 return $provider->matches($this);
 } elseif ($provider instanceof $this) {
 return $this->matchSpecific($provider);
 }

 return true;
 }

 public function setPrettyString($prettyString)
 {
 $this->prettyString = $prettyString;
 }

 public function getPrettyString()
 {
 if ($this->prettyString) {
 return $this->prettyString;
 }

 return $this->__toString();
 }


 
 
 }
 <?php











 namespace Composer\Package\LinkConstraint;








 class VersionConstraint extends SpecificConstraint
 {
 const OP_EQ = 0;
 const OP_LT = 1;
 const OP_LE = 2;
 const OP_GT = 3;
 const OP_GE = 4;
 const OP_NE = 5;

 private static $transOpStr = array(
 '=' => self::OP_EQ,
 '==' => self::OP_EQ,
 '<' => self::OP_LT,
 '<=' => self::OP_LE,
 '>' => self::OP_GT,
 '>=' => self::OP_GE,
 '<>' => self::OP_NE,
 '!=' => self::OP_NE,
 );

 private static $transOpInt = array(
 self::OP_EQ => '==',
 self::OP_LT => '<',
 self::OP_LE => '<=',
 self::OP_GT => '>',
 self::OP_GE => '>=',
 self::OP_NE => '!=',
 );

 private $operator;
 private $version;







 public function __construct($operator, $version)
 {
 $this->operator = self::$transOpStr[$operator];
 $this->version = $version;
 }

 public function versionCompare($a, $b, $operator, $compareBranches = false)
 {
 $aIsBranch = 'dev-' === substr($a, 0, 4);
 $bIsBranch = 'dev-' === substr($b, 0, 4);
 if ($aIsBranch && $bIsBranch) {
 return $operator == '==' && $a === $b;
 }


 if (!$compareBranches && ($aIsBranch || $bIsBranch)) {
 return false;
 }

 return version_compare($a, $b, $operator);
 }






 public function matchSpecific(VersionConstraint $provider, $compareBranches = false)
 {
 $noEqualOp = str_replace('=', '', self::$transOpInt[$this->operator]);
 $providerNoEqualOp = str_replace('=', '', self::$transOpInt[$provider->operator]);

 $isEqualOp = self::OP_EQ === $this->operator;
 $isNonEqualOp = self::OP_NE === $this->operator;
 $isProviderEqualOp = self::OP_EQ === $provider->operator;
 $isProviderNonEqualOp = self::OP_NE === $provider->operator;


 
 if ($isNonEqualOp || $isProviderNonEqualOp) {
 return !$isEqualOp && !$isProviderEqualOp
 || $this->versionCompare($provider->version, $this->version, '!=', $compareBranches);
 }


 
 if ($this->operator !== self::OP_EQ && $noEqualOp == $providerNoEqualOp) {
 return true;
 }

 if ($this->versionCompare($provider->version, $this->version, self::$transOpInt[$this->operator], $compareBranches)) {

 
 if ($provider->version == $this->version && self::$transOpInt[$provider->operator] == $providerNoEqualOp && self::$transOpInt[$this->operator] != $noEqualOp) {
 return false;
 }

 return true;
 }

 return false;
 }

 public function __toString()
 {
 return self::$transOpInt[$this->operator].' '.$this->version;
 }
 }
 <?php











 namespace Composer\Package\Loader;

 use Composer\Package;
 use Composer\Package\AliasPackage;
 use Composer\Package\Link;
 use Composer\Package\RootAliasPackage;
 use Composer\Package\RootPackageInterface;
 use Composer\Package\Version\VersionParser;





 class ArrayLoader implements LoaderInterface
 {
 protected $versionParser;
 protected $loadOptions;

 public function __construct(VersionParser $parser = null, $loadOptions = false)
 {
 if (!$parser) {
 $parser = new VersionParser;
 }
 $this->versionParser = $parser;
 $this->loadOptions = $loadOptions;
 }

 public function load(array $config, $class = 'Composer\Package\CompletePackage')
 {
 if (!isset($config['name'])) {
 throw new \UnexpectedValueException('Unknown package has no name defined ('.json_encode($config).').');
 }
 if (!isset($config['version'])) {
 throw new \UnexpectedValueException('Package '.$config['name'].' has no version defined.');
 }


 if (isset($config['version_normalized'])) {
 $version = $config['version_normalized'];
 } else {
 $version = $this->versionParser->normalize($config['version']);
 }
 $package = new $class($config['name'], $version, $config['version']);
 $package->setType(isset($config['type']) ? strtolower($config['type']) : 'library');

 if (isset($config['target-dir'])) {
 $package->setTargetDir($config['target-dir']);
 }

 if (isset($config['extra']) && is_array($config['extra'])) {
 $package->setExtra($config['extra']);
 }

 if (isset($config['bin'])) {
 if (!is_array($config['bin'])) {
 throw new \UnexpectedValueException('Package '.$config['name'].'\'s bin key should be an array, '.gettype($config['bin']).' given.');
 }
 foreach ($config['bin'] as $key => $bin) {
 $config['bin'][$key] = ltrim($bin, '/');
 }
 $package->setBinaries($config['bin']);
 }

 if (isset($config['installation-source'])) {
 $package->setInstallationSource($config['installation-source']);
 }

 if (isset($config['source'])) {
 if (!isset($config['source']['type']) || !isset($config['source']['url']) || !isset($config['source']['reference'])) {
 throw new \UnexpectedValueException(sprintf(
 "Package %s's source key should be specified as {\"type\": ..., \"url\": ..., \"reference\": ...},\n%s given.",
 $config['name'],
 json_encode($config['source'])
 ));
 }
 $package->setSourceType($config['source']['type']);
 $package->setSourceUrl($config['source']['url']);
 $package->setSourceReference($config['source']['reference']);
 if (isset($config['source']['mirrors'])) {
 $package->setSourceMirrors($config['source']['mirrors']);
 }
 }

 if (isset($config['dist'])) {
 if (!isset($config['dist']['type'])
 || !isset($config['dist']['url'])) {
 throw new \UnexpectedValueException(sprintf(
 "Package %s's dist key should be specified as ".
 "{\"type\": ..., \"url\": ..., \"reference\": ..., \"shasum\": ...},\n%s given.",
 $config['name'],
 json_encode($config['dist'])
 ));
 }
 $package->setDistType($config['dist']['type']);
 $package->setDistUrl($config['dist']['url']);
 $package->setDistReference(isset($config['dist']['reference']) ? $config['dist']['reference'] : null);
 $package->setDistSha1Checksum(isset($config['dist']['shasum']) ? $config['dist']['shasum'] : null);
 if (isset($config['dist']['mirrors'])) {
 $package->setDistMirrors($config['dist']['mirrors']);
 }
 }

 foreach (Package\BasePackage::$supportedLinkTypes as $type => $opts) {
 if (isset($config[$type])) {
 $method = 'set'.ucfirst($opts['method']);
 $package->{$method}(
 $this->parseLinks(
 $package->getName(),
 $package->getPrettyVersion(),
 $opts['description'],
 $config[$type]
 )
 );
 }
 }

 if (isset($config['suggest']) && is_array($config['suggest'])) {
 foreach ($config['suggest'] as $target => $reason) {
 if ('self.version' === trim($reason)) {
 $config['suggest'][$target] = $package->getPrettyVersion();
 }
 }
 $package->setSuggests($config['suggest']);
 }

 if (isset($config['autoload'])) {
 $package->setAutoload($config['autoload']);
 }

 if (isset($config['autoload-dev'])) {
 $package->setDevAutoload($config['autoload-dev']);
 }

 if (isset($config['include-path'])) {
 $package->setIncludePaths($config['include-path']);
 }

 if (!empty($config['time'])) {
 $time = preg_match('/^\d++$/D', $config['time']) ? '@'.$config['time'] : $config['time'];

 try {
 $date = new \DateTime($time, new \DateTimeZone('UTC'));
 $package->setReleaseDate($date);
 } catch (\Exception $e) {
 }
 }

 if (!empty($config['notification-url'])) {
 $package->setNotificationUrl($config['notification-url']);
 }

 if (!empty($config['archive']['exclude'])) {
 $package->setArchiveExcludes($config['archive']['exclude']);
 }

 if ($package instanceof Package\CompletePackageInterface) {
 if (isset($config['scripts']) && is_array($config['scripts'])) {
 foreach ($config['scripts'] as $event => $listeners) {
 $config['scripts'][$event] = (array) $listeners;
 }
 $package->setScripts($config['scripts']);
 }

 if (!empty($config['description']) && is_string($config['description'])) {
 $package->setDescription($config['description']);
 }

 if (!empty($config['homepage']) && is_string($config['homepage'])) {
 $package->setHomepage($config['homepage']);
 }

 if (!empty($config['keywords']) && is_array($config['keywords'])) {
 $package->setKeywords($config['keywords']);
 }

 if (!empty($config['license'])) {
 $package->setLicense(is_array($config['license']) ? $config['license'] : array($config['license']));
 }

 if (!empty($config['authors']) && is_array($config['authors'])) {
 $package->setAuthors($config['authors']);
 }

 if (isset($config['support'])) {
 $package->setSupport($config['support']);
 }

 if (isset($config['abandoned'])) {
 $package->setAbandoned($config['abandoned']);
 }
 }

 if ($aliasNormalized = $this->getBranchAlias($config)) {
 if ($package instanceof RootPackageInterface) {
 $package = new RootAliasPackage($package, $aliasNormalized, preg_replace('{(\.9{7})+}', '.x', $aliasNormalized));
 } else {
 $package = new AliasPackage($package, $aliasNormalized, preg_replace('{(\.9{7})+}', '.x', $aliasNormalized));
 }
 }

 if ($this->loadOptions && isset($config['transport-options'])) {
 $package->setTransportOptions($config['transport-options']);
 }

 return $package;
 }








 public function parseLinks($source, $sourceVersion, $description, $links)
 {
 $res = array();
 foreach ($links as $target => $constraint) {
 if ('self.version' === $constraint) {
 $parsedConstraint = $this->versionParser->parseConstraints($sourceVersion);
 } else {
 $parsedConstraint = $this->versionParser->parseConstraints($constraint);
 }

 $res[strtolower($target)] = new Link($source, $target, $parsedConstraint, $description, $constraint);
 }

 return $res;
 }







 public function getBranchAlias(array $config)
 {
 if (('dev-' !== substr($config['version'], 0, 4) && '-dev' !== substr($config['version'], -4))
 || !isset($config['extra']['branch-alias'])
 || !is_array($config['extra']['branch-alias'])
 ) {
 return;
 }

 foreach ($config['extra']['branch-alias'] as $sourceBranch => $targetBranch) {

 if ('-dev' !== substr($targetBranch, -4)) {
 continue;
 }


 $validatedTargetBranch = $this->versionParser->normalizeBranch(substr($targetBranch, 0, -4));
 if ('-dev' !== substr($validatedTargetBranch, -4)) {
 continue;
 }


 if (strtolower($config['version']) !== strtolower($sourceBranch)) {
 continue;
 }


 if (($sourcePrefix = $this->versionParser->parseNumericAliasPrefix($sourceBranch))
 && ($targetPrefix = $this->versionParser->parseNumericAliasPrefix($targetBranch))
 && (stripos($targetPrefix, $sourcePrefix) !== 0)
 ) {
 continue;
 }

 return $validatedTargetBranch;
 }
 }
 }
 <?php











 namespace Composer\Package\Loader;




 class InvalidPackageException extends \Exception
 {
 private $errors;
 private $warnings;
 private $data;

 public function __construct(array $errors, array $warnings, array $data)
 {
 $this->errors = $errors;
 $this->warnings = $warnings;
 $this->data = $data;
 parent::__construct("Invalid package information: \n".implode("\n", array_merge($errors, $warnings)));
 }

 public function getData()
 {
 return $this->data;
 }

 public function getErrors()
 {
 return $this->errors;
 }

 public function getWarnings()
 {
 return $this->warnings;
 }
 }
 <?php











 namespace Composer\Package\Loader;

 use Composer\Json\JsonFile;




 class JsonLoader
 {
 private $loader;

 public function __construct(LoaderInterface $loader)
 {
 $this->loader = $loader;
 }





 public function load($json)
 {
 if ($json instanceof JsonFile) {
 $config = $json->read();
 } elseif (file_exists($json)) {
 $config = JsonFile::parseJson(file_get_contents($json), $json);
 } elseif (is_string($json)) {
 $config = JsonFile::parseJson($json);
 }

 return $this->loader->load($config);
 }
 }
 <?php











 namespace Composer\Package\Loader;






 interface LoaderInterface
 {







 public function load(array $package, $class = 'Composer\Package\CompletePackage');
 }
 <?php











 namespace Composer\Package\Loader;

 use Composer\Package\BasePackage;
 use Composer\Package\AliasPackage;
 use Composer\Config;
 use Composer\Factory;
 use Composer\Package\Version\VersionParser;
 use Composer\Repository\RepositoryManager;
 use Composer\Repository\Vcs\HgDriver;
 use Composer\IO\NullIO;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\Git as GitUtil;
 use Composer\Util\Svn as SvnUtil;








 class RootPackageLoader extends ArrayLoader
 {
 private $manager;
 private $config;
 private $process;

 public function __construct(RepositoryManager $manager, Config $config, VersionParser $parser = null, ProcessExecutor $process = null)
 {
 $this->manager = $manager;
 $this->config = $config;
 $this->process = $process ?: new ProcessExecutor();
 parent::__construct($parser);
 }

 public function load(array $config, $class = 'Composer\Package\RootPackage')
 {
 if (!isset($config['name'])) {
 $config['name'] = '__root__';
 }
 $autoVersioned = false;
 if (!isset($config['version'])) {

 if (getenv('COMPOSER_ROOT_VERSION')) {
 $version = getenv('COMPOSER_ROOT_VERSION');
 } else {
 $version = $this->guessVersion($config);
 }

 if (!$version) {
 $version = '1.0.0';
 $autoVersioned = true;
 }

 $config['version'] = $version;
 }

 $realPackage = $package = parent::load($config, $class);
 if ($realPackage instanceof AliasPackage) {
 $realPackage = $package->getAliasOf();
 }

 if ($autoVersioned) {
 $realPackage->replaceVersion($realPackage->getVersion(), 'No version set (parsed as 1.0.0)');
 }

 if (isset($config['minimum-stability'])) {
 $realPackage->setMinimumStability(VersionParser::normalizeStability($config['minimum-stability']));
 }

 $aliases = array();
 $stabilityFlags = array();
 $references = array();
 foreach (array('require', 'require-dev') as $linkType) {
 if (isset($config[$linkType])) {
 $linkInfo = BasePackage::$supportedLinkTypes[$linkType];
 $method = 'get'.ucfirst($linkInfo['method']);
 $links = array();
 foreach ($realPackage->$method() as $link) {
 $links[$link->getTarget()] = $link->getConstraint()->getPrettyString();
 }
 $aliases = $this->extractAliases($links, $aliases);
 $stabilityFlags = $this->extractStabilityFlags($links, $stabilityFlags, $realPackage->getMinimumStability());
 $references = $this->extractReferences($links, $references);
 }
 }

 $realPackage->setAliases($aliases);
 $realPackage->setStabilityFlags($stabilityFlags);
 $realPackage->setReferences($references);

 if (isset($config['prefer-stable'])) {
 $realPackage->setPreferStable((bool) $config['prefer-stable']);
 }

 $repos = Factory::createDefaultRepositories(null, $this->config, $this->manager);
 foreach ($repos as $repo) {
 $this->manager->addRepository($repo);
 }
 $realPackage->setRepositories($this->config->getRepositories());

 return $package;
 }

 private function extractAliases(array $requires, array $aliases)
 {
 foreach ($requires as $reqName => $reqVersion) {
 if (preg_match('{^([^,\s#]+)(?:#[^ ]+)? +as +([^,\s]+)$}', $reqVersion, $match)) {
 $aliases[] = array(
 'package' => strtolower($reqName),
 'version' => $this->versionParser->normalize($match[1], $reqVersion),
 'alias' => $match[2],
 'alias_normalized' => $this->versionParser->normalize($match[2], $reqVersion),
 );
 }
 }

 return $aliases;
 }

 private function extractStabilityFlags(array $requires, array $stabilityFlags, $minimumStability)
 {
 $stabilities = BasePackage::$stabilities;
 $minimumStability = $stabilities[$minimumStability];
 foreach ($requires as $reqName => $reqVersion) {

 if (preg_match('{^[^@]*?@('.implode('|', array_keys($stabilities)).')$}i', $reqVersion, $match)) {
 $name = strtolower($reqName);
 $stability = $stabilities[VersionParser::normalizeStability($match[1])];

 if (isset($stabilityFlags[$name]) && $stabilityFlags[$name] > $stability) {
 continue;
 }
 $stabilityFlags[$name] = $stability;

 continue;
 }


 
 $reqVersion = preg_replace('{^([^,\s@]+) as .+$}', '$1', $reqVersion);
 if (preg_match('{^[^,\s@]+$}', $reqVersion) && 'stable' !== ($stabilityName = VersionParser::parseStability($reqVersion))) {
 $name = strtolower($reqName);
 $stability = $stabilities[$stabilityName];
 if ((isset($stabilityFlags[$name]) && $stabilityFlags[$name] > $stability) || ($minimumStability > $stability)) {
 continue;
 }
 $stabilityFlags[$name] = $stability;
 }
 }

 return $stabilityFlags;
 }

 private function extractReferences(array $requires, array $references)
 {
 foreach ($requires as $reqName => $reqVersion) {
 $reqVersion = preg_replace('{^([^,\s@]+) as .+$}', '$1', $reqVersion);
 if (preg_match('{^[^,\s@]+?#([a-f0-9]+)$}', $reqVersion, $match) && 'dev' === ($stabilityName = VersionParser::parseStability($reqVersion))) {
 $name = strtolower($reqName);
 $references[$name] = $match[1];
 }
 }

 return $references;
 }

 private function guessVersion(array $config)
 {
 if (function_exists('proc_open')) {
 $version = $this->guessGitVersion($config);
 if (null !== $version) {
 return $version;
 }

 $version = $this->guessHgVersion($config);
 if (null !== $version) {
 return $version;
 }

 return $this->guessSvnVersion($config);
 }
 }

 private function guessGitVersion(array $config)
 {
 GitUtil::cleanEnv();


 if (0 === $this->process->execute('git describe --exact-match --tags', $output)) {
 try {
 return $this->versionParser->normalize(trim($output));
 } catch (\Exception $e) {
 }
 }


 if (0 === $this->process->execute('git branch --no-color --no-abbrev -v', $output)) {
 $branches = array();
 $isFeatureBranch = false;
 $version = null;


 foreach ($this->process->splitLines($output) as $branch) {
 if ($branch && preg_match('{^(?:\* ) *(\(no branch\)|\(detached from \S+\)|\S+) *([a-f0-9]+) .*$}', $branch, $match)) {
 if ($match[1] === '(no branch)' || substr($match[1], 0, 10) === '(detached ') {
 $version = 'dev-'.$match[2];
 $isFeatureBranch = true;
 } else {
 $version = $this->versionParser->normalizeBranch($match[1]);
 $isFeatureBranch = 0 === strpos($version, 'dev-');
 if ('9999999-dev' === $version) {
 $version = 'dev-'.$match[1];
 }
 }
 }

 if ($branch && !preg_match('{^ *[^/]+/HEAD }', $branch)) {
 if (preg_match('{^(?:\* )? *(\S+) *([a-f0-9]+) .*$}', $branch, $match)) {
 $branches[] = $match[1];
 }
 }
 }

 if (!$isFeatureBranch) {
 return $version;
 }


 $version = $this->guessFeatureVersion($config, $version, $branches, 'git rev-list %candidate%..%branch%');

 return $version;
 }
 }

 private function guessHgVersion(array $config)
 {

 if (0 === $this->process->execute('hg branch', $output)) {
 $branch = trim($output);
 $version = $this->versionParser->normalizeBranch($branch);
 $isFeatureBranch = 0 === strpos($version, 'dev-');

 if ('9999999-dev' === $version) {
 $version = 'dev-'.$branch;
 }

 if (!$isFeatureBranch) {
 return $version;
 }


 $config = array('url' => getcwd());
 $driver = new HgDriver($config, new NullIO(), $this->config, $this->process);
 $branches = array_keys($driver->getBranches());


 $version = $this->guessFeatureVersion($config, $version, $branches, 'hg log -r "not ancestors(\'%candidate%\') and ancestors(\'%branch%\')" --template "{node}\\n"');

 return $version;
 }
 }

 private function guessFeatureVersion(array $config, $version, array $branches, $scmCmdline)
 {

 
 if ((isset($config['extra']['branch-alias']) && !isset($config['extra']['branch-alias'][$version]))
 || strpos(json_encode($config), '"self.version"')
 ) {
 $branch = preg_replace('{^dev-}', '', $version);
 $length = PHP_INT_MAX;

 $nonFeatureBranches = '';
 if (!empty($config['non-feature-branches'])) {
 $nonFeatureBranches = implode('|', $config['non-feature-branches']);
 }

 foreach ($branches as $candidate) {

 if ($candidate === $branch && preg_match('{^(' . $nonFeatureBranches . ')$}', $candidate)) {
 return $version;
 }


 if ($candidate === $branch || !preg_match('{^(master|trunk|default|develop|\d+\..+)$}', $candidate, $match)) {
 continue;
 }

 $cmdLine = str_replace(array('%candidate%', '%branch%'), array($candidate, $branch), $scmCmdline);
 if (0 !== $this->process->execute($cmdLine, $output)) {
 continue;
 }

 if (strlen($output) < $length) {
 $length = strlen($output);
 $version = $this->versionParser->normalizeBranch($candidate);
 if ('9999999-dev' === $version) {
 $version = 'dev-'.$match[1];
 }
 }
 }
 }

 return $version;
 }

 private function guessSvnVersion(array $config)
 {
 SvnUtil::cleanEnv();


 if (0 === $this->process->execute('svn info --xml', $output)) {
 $trunkPath = isset($config['trunk-path']) ? preg_quote($config['trunk-path'], '#') : 'trunk';
 $branchesPath = isset($config['branches-path']) ? preg_quote($config['branches-path'], '#') : 'branches';
 $tagsPath = isset($config['tags-path']) ? preg_quote($config['tags-path'], '#') : 'tags';

 $urlPattern = '#<url>.*/('.$trunkPath.'|('.$branchesPath.'|'. $tagsPath .')/(.*))</url>#';

 if (preg_match($urlPattern, $output, $matches)) {
 if (isset($matches[2]) && ($branchesPath === $matches[2] || $tagsPath === $matches[2])) {

 $version = $this->versionParser->normalizeBranch($matches[3]);
 if ('9999999-dev' === $version) {
 $version = 'dev-'.$matches[3];
 }

 return $version;
 }

 return $this->versionParser->normalize(trim($matches[1]));
 }
 }
 }
 }
 <?php











 namespace Composer\Package\Loader;

 use Composer\Package;
 use Composer\Package\BasePackage;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Package\Version\VersionParser;
 use Composer\Repository\PlatformRepository;




 class ValidatingArrayLoader implements LoaderInterface
 {
 const CHECK_ALL = 1;
 const CHECK_UNBOUND_CONSTRAINTS = 1;

 private $loader;
 private $versionParser;
 private $errors;
 private $warnings;
 private $config;
 private $strictName;
 private $flags;

 public function __construct(LoaderInterface $loader, $strictName = true, VersionParser $parser = null, $flags = 0)
 {
 $this->loader = $loader;
 $this->versionParser = $parser ?: new VersionParser();
 $this->strictName = $strictName;
 $this->flags = $flags;
 }

 public function load(array $config, $class = 'Composer\Package\CompletePackage')
 {
 $this->errors = array();
 $this->warnings = array();
 $this->config = $config;

 if ($this->strictName) {
 $this->validateRegex('name', '[A-Za-z0-9][A-Za-z0-9_.-]*/[A-Za-z0-9][A-Za-z0-9_.-]*', true);
 } else {
 $this->validateString('name', true);
 }

 if (!empty($this->config['version'])) {
 try {
 $this->versionParser->normalize($this->config['version']);
 } catch (\Exception $e) {
 $this->errors[] = 'version : invalid value ('.$this->config['version'].'): '.$e->getMessage();
 unset($this->config['version']);
 }
 }

 $this->validateRegex('type', '[A-Za-z0-9-]+');
 $this->validateString('target-dir');
 $this->validateArray('extra');
 $this->validateFlatArray('bin');
 $this->validateArray('scripts'); 
 $this->validateString('description');
 $this->validateUrl('homepage');
 $this->validateFlatArray('keywords', '[\p{N}\p{L} ._-]+');

 if (isset($this->config['license'])) {
 if (is_string($this->config['license'])) {
 $this->validateRegex('license', '[A-Za-z0-9+. ()-]+');
 } else {
 $this->validateFlatArray('license', '[A-Za-z0-9+. ()-]+');
 }
 }

 $this->validateString('time');
 if (!empty($this->config['time'])) {
 try {
 $date = new \DateTime($this->config['time'], new \DateTimeZone('UTC'));
 } catch (\Exception $e) {
 $this->errors[] = 'time : invalid value ('.$this->config['time'].'): '.$e->getMessage();
 unset($this->config['time']);
 }
 }

 if ($this->validateArray('authors') && !empty($this->config['authors'])) {
 foreach ($this->config['authors'] as $key => $author) {
 if (!is_array($author)) {
 $this->errors[] = 'authors.'.$key.' : should be an array, '.gettype($author).' given';
 unset($this->config['authors'][$key]);
 continue;
 }
 foreach (array('homepage', 'email', 'name', 'role') as $authorData) {
 if (isset($author[$authorData]) && !is_string($author[$authorData])) {
 $this->errors[] = 'authors.'.$key.'.'.$authorData.' : invalid value, must be a string';
 unset($this->config['authors'][$key][$authorData]);
 }
 }
 if (isset($author['homepage']) && !$this->filterUrl($author['homepage'])) {
 $this->warnings[] = 'authors.'.$key.'.homepage : invalid value ('.$author['homepage'].'), must be an http/https URL';
 unset($this->config['authors'][$key]['homepage']);
 }
 if (isset($author['email']) && !filter_var($author['email'], FILTER_VALIDATE_EMAIL)) {
 $this->warnings[] = 'authors.'.$key.'.email : invalid value ('.$author['email'].'), must be a valid email address';
 unset($this->config['authors'][$key]['email']);
 }
 if (empty($this->config['authors'][$key])) {
 unset($this->config['authors'][$key]);
 }
 }
 if (empty($this->config['authors'])) {
 unset($this->config['authors']);
 }
 }

 if ($this->validateArray('support') && !empty($this->config['support'])) {
 foreach (array('issues', 'forum', 'wiki', 'source', 'email', 'irc', 'docs') as $key) {
 if (isset($this->config['support'][$key]) && !is_string($this->config['support'][$key])) {
 $this->errors[] = 'support.'.$key.' : invalid value, must be a string';
 unset($this->config['support'][$key]);
 }
 }

 if (isset($this->config['support']['email']) && !filter_var($this->config['support']['email'], FILTER_VALIDATE_EMAIL)) {
 $this->warnings[] = 'support.email : invalid value ('.$this->config['support']['email'].'), must be a valid email address';
 unset($this->config['support']['email']);
 }

 if (isset($this->config['support']['irc']) && !$this->filterUrl($this->config['support']['irc'], array('irc'))) {
 $this->warnings[] = 'support.irc : invalid value ('.$this->config['support']['irc'].'), must be a irc://<server>/<channel> URL';
 unset($this->config['support']['irc']);
 }

 foreach (array('issues', 'forum', 'wiki', 'source', 'docs') as $key) {
 if (isset($this->config['support'][$key]) && !$this->filterUrl($this->config['support'][$key])) {
 $this->warnings[] = 'support.'.$key.' : invalid value ('.$this->config['support'][$key].'), must be an http/https URL';
 unset($this->config['support'][$key]);
 }
 }
 if (empty($this->config['support'])) {
 unset($this->config['support']);
 }
 }

 $unboundConstraint = new VersionConstraint('=', $this->versionParser->normalize('dev-master'));

 foreach (array_keys(BasePackage::$supportedLinkTypes) as $linkType) {
 if ($this->validateArray($linkType) && isset($this->config[$linkType])) {
 foreach ($this->config[$linkType] as $package => $constraint) {
 if (!preg_match('{^[A-Za-z0-9_./-]+$}', $package)) {
 $this->warnings[] = $linkType.'.'.$package.' : invalid key, package names must be strings containing only [A-Za-z0-9_./-]';
 }
 if (!is_string($constraint)) {
 $this->errors[] = $linkType.'.'.$package.' : invalid value, must be a string containing a version constraint';
 unset($this->config[$linkType][$package]);
 } elseif ('self.version' !== $constraint) {
 try {
 $linkConstraint = $this->versionParser->parseConstraints($constraint);
 } catch (\Exception $e) {
 $this->errors[] = $linkType.'.'.$package.' : invalid version constraint ('.$e->getMessage().')';
 unset($this->config[$linkType][$package]);
 continue;
 }


 if (
 ($this->flags & self::CHECK_UNBOUND_CONSTRAINTS)
 && 'require' === $linkType
 && $linkConstraint->matches($unboundConstraint)
 && !preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $package)
 ) {
 $this->warnings[] = $linkType.'.'.$package.' : unbound version constraints ('.$constraint.') should be avoided';
 }
 }
 }
 }
 }

 if ($this->validateArray('suggest') && !empty($this->config['suggest'])) {
 foreach ($this->config['suggest'] as $package => $description) {
 if (!is_string($description)) {
 $this->errors[] = 'suggest.'.$package.' : invalid value, must be a string describing why the package is suggested';
 unset($this->config['suggest'][$package]);
 }
 }
 }

 if ($this->validateString('minimum-stability') && !empty($this->config['minimum-stability'])) {
 if (!isset(BasePackage::$stabilities[$this->config['minimum-stability']])) {
 $this->errors[] = 'minimum-stability : invalid value ('.$this->config['minimum-stability'].'), must be one of '.implode(', ', array_keys(BasePackage::$stabilities));
 unset($this->config['minimum-stability']);
 }
 }

 if ($this->validateArray('autoload') && !empty($this->config['autoload'])) {
 $types = array('psr-0', 'psr-4', 'classmap', 'files');
 foreach ($this->config['autoload'] as $type => $typeConfig) {
 if (!in_array($type, $types)) {
 $this->errors[] = 'autoload : invalid value ('.$type.'), must be one of '.implode(', ', $types);
 unset($this->config['autoload'][$type]);
 }
 if ($type === 'psr-4') {
 foreach ($typeConfig as $namespace => $dirs) {
 if ($namespace !== '' && '\\' !== substr($namespace, -1)) {
 $this->errors[] = 'autoload.psr-4 : invalid value ('.$namespace.'), namespaces must end with a namespace separator, should be '.$namespace.'\\';
 }
 }
 }
 }
 }

 if (!empty($this->config['autoload']['psr-4']) && !empty($this->config['target-dir'])) {
 $this->errors[] = 'target-dir : this can not be used together with the autoload.psr-4 setting, remove target-dir to upgrade to psr-4';

 
 unset($this->config['autoload']['psr-4']);
 }


 


 

 $this->validateFlatArray('include-path');
 $this->validateArray('transport-options');


 if (isset($this->config['extra']['branch-alias'])) {
 if (!is_array($this->config['extra']['branch-alias'])) {
 $this->errors[] = 'extra.branch-alias : must be an array of versions => aliases';
 } else {
 foreach ($this->config['extra']['branch-alias'] as $sourceBranch => $targetBranch) {

 if ('-dev' !== substr($targetBranch, -4)) {
 $this->warnings[] = 'extra.branch-alias.'.$sourceBranch.' : the target branch ('.$targetBranch.') must end in -dev';
 unset($this->config['extra']['branch-alias'][$sourceBranch]);

 continue;
 }


 $validatedTargetBranch = $this->versionParser->normalizeBranch(substr($targetBranch, 0, -4));
 if ('-dev' !== substr($validatedTargetBranch, -4)) {
 $this->warnings[] = 'extra.branch-alias.'.$sourceBranch.' : the target branch ('.$targetBranch.') must be a parseable number like 2.0-dev';
 unset($this->config['extra']['branch-alias'][$sourceBranch]);

 continue;
 }


 if (($sourcePrefix = $this->versionParser->parseNumericAliasPrefix($sourceBranch))
 && ($targetPrefix = $this->versionParser->parseNumericAliasPrefix($targetBranch))
 && (stripos($targetPrefix, $sourcePrefix) !== 0)
 ) {
 $this->warnings[] = 'extra.branch-alias.'.$sourceBranch.' : the target branch ('.$targetBranch.') is not a valid numeric alias for this version';
 unset($this->config['extra']['branch-alias'][$sourceBranch]);
 }
 }
 }
 }

 if ($this->errors) {
 throw new InvalidPackageException($this->errors, $this->warnings, $config);
 }

 $package = $this->loader->load($this->config, $class);
 $this->config = null;

 return $package;
 }

 public function getWarnings()
 {
 return $this->warnings;
 }

 public function getErrors()
 {
 return $this->errors;
 }

 private function validateRegex($property, $regex, $mandatory = false)
 {
 if (!$this->validateString($property, $mandatory)) {
 return false;
 }

 if (!preg_match('{^'.$regex.'$}u', $this->config[$property])) {
 $message = $property.' : invalid value ('.$this->config[$property].'), must match '.$regex;
 if ($mandatory) {
 $this->errors[] = $message;
 } else {
 $this->warnings[] = $message;
 }
 unset($this->config[$property]);

 return false;
 }

 return true;
 }

 private function validateString($property, $mandatory = false)
 {
 if (isset($this->config[$property]) && !is_string($this->config[$property])) {
 $this->errors[] = $property.' : should be a string, '.gettype($this->config[$property]).' given';
 unset($this->config[$property]);

 return false;
 }

 if (!isset($this->config[$property]) || trim($this->config[$property]) === '') {
 if ($mandatory) {
 $this->errors[] = $property.' : must be present';
 }
 unset($this->config[$property]);

 return false;
 }

 return true;
 }

 private function validateArray($property, $mandatory = false)
 {
 if (isset($this->config[$property]) && !is_array($this->config[$property])) {
 $this->errors[] = $property.' : should be an array, '.gettype($this->config[$property]).' given';
 unset($this->config[$property]);

 return false;
 }

 if (!isset($this->config[$property]) || !count($this->config[$property])) {
 if ($mandatory) {
 $this->errors[] = $property.' : must be present and contain at least one element';
 }
 unset($this->config[$property]);

 return false;
 }

 return true;
 }

 private function validateFlatArray($property, $regex = null, $mandatory = false)
 {
 if (!$this->validateArray($property, $mandatory)) {
 return false;
 }

 $pass = true;
 foreach ($this->config[$property] as $key => $value) {
 if (!is_string($value) && !is_numeric($value)) {
 $this->errors[] = $property.'.'.$key.' : must be a string or int, '.gettype($value).' given';
 unset($this->config[$property][$key]);
 $pass = false;

 continue;
 }

 if ($regex && !preg_match('{^'.$regex.'$}u', $value)) {
 $this->warnings[] = $property.'.'.$key.' : invalid value ('.$value.'), must match '.$regex;
 unset($this->config[$property][$key]);
 $pass = false;
 }
 }

 return $pass;
 }

 private function validateUrl($property, $mandatory = false)
 {
 if (!$this->validateString($property, $mandatory)) {
 return false;
 }

 if (!$this->filterUrl($this->config[$property])) {
 $this->warnings[] = $property.' : invalid value ('.$this->config[$property].'), must be an http/https URL';
 unset($this->config[$property]);

 return false;
 }

 return true;
 }

 private function filterUrl($value, array $schemes = array('http', 'https'))
 {
 if ($value === '') {
 return true;
 }

 $bits = parse_url($value);
 if (empty($bits['scheme']) || empty($bits['host'])) {
 return false;
 }

 if (!in_array($bits['scheme'], $schemes, true)) {
 return false;
 }

 return true;
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Json\JsonFile;
 use Composer\Installer\InstallationManager;
 use Composer\Repository\RepositoryManager;
 use Composer\Util\ProcessExecutor;
 use Composer\Repository\ArrayRepository;
 use Composer\Package\Dumper\ArrayDumper;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Util\Git as GitUtil;
 use Composer\IO\IOInterface;







 class Locker
 {
 private $lockFile;
 private $repositoryManager;
 private $installationManager;
 private $hash;
 private $loader;
 private $dumper;
 private $process;
 private $lockDataCache;










 public function __construct(IOInterface $io, JsonFile $lockFile, RepositoryManager $repositoryManager, InstallationManager $installationManager, $hash)
 {
 $this->lockFile = $lockFile;
 $this->repositoryManager = $repositoryManager;
 $this->installationManager = $installationManager;
 $this->hash = $hash;
 $this->loader = new ArrayLoader(null, true);
 $this->dumper = new ArrayDumper();
 $this->process = new ProcessExecutor($io);
 }






 public function isLocked()
 {
 if (!$this->lockFile->exists()) {
 return false;
 }

 $data = $this->getLockData();

 return isset($data['packages']);
 }






 public function isFresh()
 {
 $lock = $this->lockFile->read();

 return $this->hash === $lock['hash'];
 }








 public function getLockedRepository($withDevReqs = false)
 {
 $lockData = $this->getLockData();
 $packages = new ArrayRepository();

 $lockedPackages = $lockData['packages'];
 if ($withDevReqs) {
 if (isset($lockData['packages-dev'])) {
 $lockedPackages = array_merge($lockedPackages, $lockData['packages-dev']);
 } else {
 throw new \RuntimeException('The lock file does not contain require-dev information, run install with the --no-dev option or run update to install those packages.');
 }
 }

 if (empty($lockedPackages)) {
 return $packages;
 }

 if (isset($lockedPackages[0]['name'])) {
 foreach ($lockedPackages as $info) {
 $packages->addPackage($this->loader->load($info));
 }

 return $packages;
 }

 throw new \RuntimeException('Your composer.lock was created before 2012-09-15, and is not supported anymore. Run "composer update" to generate a new one.');
 }







 public function getPlatformRequirements($withDevReqs = false)
 {
 $lockData = $this->getLockData();
 $requirements = array();

 if (!empty($lockData['platform'])) {
 $requirements = $this->loader->parseLinks(
 '__ROOT__',
 '1.0.0',
 'requires',
 isset($lockData['platform']) ? $lockData['platform'] : array()
 );
 }

 if ($withDevReqs && !empty($lockData['platform-dev'])) {
 $devRequirements = $this->loader->parseLinks(
 '__ROOT__',
 '1.0.0',
 'requires',
 isset($lockData['platform-dev']) ? $lockData['platform-dev'] : array()
 );

 $requirements = array_merge($requirements, $devRequirements);
 }

 return $requirements;
 }

 public function getMinimumStability()
 {
 $lockData = $this->getLockData();

 return isset($lockData['minimum-stability']) ? $lockData['minimum-stability'] : 'stable';
 }

 public function getStabilityFlags()
 {
 $lockData = $this->getLockData();

 return isset($lockData['stability-flags']) ? $lockData['stability-flags'] : array();
 }

 public function getPreferStable()
 {
 $lockData = $this->getLockData();


 
 return isset($lockData['prefer-stable']) ? $lockData['prefer-stable'] : null;
 }

 public function getPreferLowest()
 {
 $lockData = $this->getLockData();


 
 return isset($lockData['prefer-lowest']) ? $lockData['prefer-lowest'] : null;
 }

 public function getPlatformOverrides()
 {
 $lockData = $this->getLockData();

 return isset($lockData['platform-overrides']) ? $lockData['platform-overrides'] : array();
 }

 public function getAliases()
 {
 $lockData = $this->getLockData();

 return isset($lockData['aliases']) ? $lockData['aliases'] : array();
 }

 public function getLockData()
 {
 if (null !== $this->lockDataCache) {
 return $this->lockDataCache;
 }

 if (!$this->lockFile->exists()) {
 throw new \LogicException('No lockfile found. Unable to read locked packages');
 }

 return $this->lockDataCache = $this->lockFile->read();
 }

















 public function setLockData(array $packages, $devPackages, array $platformReqs, $platformDevReqs, array $aliases, $minimumStability, array $stabilityFlags, $preferStable, $preferLowest, array $platformOverrides)
 {
 $lock = array(
 '_readme' => array('This file locks the dependencies of your project to a known state',
 'Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file',
 'This file is @gener'.'ated automatically'),
 'hash' => $this->hash,
 'packages' => null,
 'packages-dev' => null,
 'aliases' => array(),
 'minimum-stability' => $minimumStability,
 'stability-flags' => $stabilityFlags,
 'prefer-stable' => $preferStable,
 'prefer-lowest' => $preferLowest,
 );

 foreach ($aliases as $package => $versions) {
 foreach ($versions as $version => $alias) {
 $lock['aliases'][] = array(
 'alias' => $alias['alias'],
 'alias_normalized' => $alias['alias_normalized'],
 'version' => $version,
 'package' => $package,
 );
 }
 }

 $lock['packages'] = $this->lockPackages($packages);
 if (null !== $devPackages) {
 $lock['packages-dev'] = $this->lockPackages($devPackages);
 }

 $lock['platform'] = $platformReqs;
 $lock['platform-dev'] = $platformDevReqs;
 if ($platformOverrides) {
 $lock['platform-overrides'] = $platformOverrides;
 }

 if (empty($lock['packages']) && empty($lock['packages-dev']) && empty($lock['platform']) && empty($lock['platform-dev'])) {
 if ($this->lockFile->exists()) {
 unlink($this->lockFile->getPath());
 }

 return false;
 }

 if (!$this->isLocked() || $lock !== $this->getLockData()) {
 $this->lockFile->write($lock);
 $this->lockDataCache = null;

 return true;
 }

 return false;
 }

 private function lockPackages(array $packages)
 {
 $locked = array();

 foreach ($packages as $package) {
 if ($package instanceof AliasPackage) {
 continue;
 }

 $name = $package->getPrettyName();
 $version = $package->getPrettyVersion();

 if (!$name || !$version) {
 throw new \LogicException(sprintf(
 'Package "%s" has no version or name and can not be locked', $package
 ));
 }

 $spec = $this->dumper->dump($package);
 unset($spec['version_normalized']);


 $time = isset($spec['time']) ? $spec['time'] : null;
 unset($spec['time']);
 if ($package->isDev() && $package->getInstallationSource() === 'source') {

 $time = $this->getPackageTime($package) ?: $time;
 }
 if (null !== $time) {
 $spec['time'] = $time;
 }

 unset($spec['installation-source']);

 $locked[] = $spec;
 }

 usort($locked, function ($a, $b) {
 $comparison = strcmp($a['name'], $b['name']);

 if (0 !== $comparison) {
 return $comparison;
 }


 return strcmp($a['version'], $b['version']);
 });

 return $locked;
 }







 private function getPackageTime(PackageInterface $package)
 {
 if (!function_exists('proc_open')) {
 return null;
 }

 $path = realpath($this->installationManager->getInstallPath($package));
 $sourceType = $package->getSourceType();
 $datetime = null;

 if ($path && in_array($sourceType, array('git', 'hg'))) {
 $sourceRef = $package->getSourceReference() ?: $package->getDistReference();
 switch ($sourceType) {
 case 'git':
 GitUtil::cleanEnv();

 if (0 === $this->process->execute('git log -n1 --pretty=%ct '.ProcessExecutor::escape($sourceRef), $output, $path) && preg_match('{^\s*\d+\s*$}', $output)) {
 $datetime = new \DateTime('@'.trim($output), new \DateTimeZone('UTC'));
 }
 break;

 case 'hg':
 if (0 === $this->process->execute('hg log --template "{date|hgdate}" -r '.ProcessExecutor::escape($sourceRef), $output, $path) && preg_match('{^\s*(\d+)\s*}', $output, $match)) {
 $datetime = new \DateTime('@'.$match[1], new \DateTimeZone('UTC'));
 }
 break;
 }
 }

 return $datetime ? $datetime->format('Y-m-d H:i:s') : null;
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Package\Version\VersionParser;
 use Composer\Util\ComposerMirror;






 class Package extends BasePackage
 {
 protected $type;
 protected $targetDir;
 protected $installationSource;
 protected $sourceType;
 protected $sourceUrl;
 protected $sourceReference;
 protected $sourceMirrors;
 protected $distType;
 protected $distUrl;
 protected $distReference;
 protected $distSha1Checksum;
 protected $distMirrors;
 protected $version;
 protected $prettyVersion;
 protected $releaseDate;
 protected $extra = array();
 protected $binaries = array();
 protected $dev;
 protected $stability;
 protected $notificationUrl;

 protected $requires = array();
 protected $conflicts = array();
 protected $provides = array();
 protected $replaces = array();
 protected $devRequires = array();
 protected $suggests = array();
 protected $autoload = array();
 protected $devAutoload = array();
 protected $includePaths = array();
 protected $archiveExcludes = array();








 public function __construct($name, $version, $prettyVersion)
 {
 parent::__construct($name);

 $this->version = $version;
 $this->prettyVersion = $prettyVersion;

 $this->stability = VersionParser::parseStability($version);
 $this->dev = $this->stability === 'dev';
 }




 public function isDev()
 {
 return $this->dev;
 }




 public function setType($type)
 {
 $this->type = $type;
 }




 public function getType()
 {
 return $this->type ?: 'library';
 }




 public function getStability()
 {
 return $this->stability;
 }




 public function setTargetDir($targetDir)
 {
 $this->targetDir = $targetDir;
 }




 public function getTargetDir()
 {
 if (null === $this->targetDir) {
 return;
 }

 return ltrim(preg_replace('{ (?:^|[\\\\/]+) \.\.? (?:[\\\\/]+|$) (?:\.\.? (?:[\\\\/]+|$) )*}x', '/', $this->targetDir), '/');
 }




 public function setExtra(array $extra)
 {
 $this->extra = $extra;
 }




 public function getExtra()
 {
 return $this->extra;
 }




 public function setBinaries(array $binaries)
 {
 $this->binaries = $binaries;
 }




 public function getBinaries()
 {
 return $this->binaries;
 }




 public function setInstallationSource($type)
 {
 $this->installationSource = $type;
 }




 public function getInstallationSource()
 {
 return $this->installationSource;
 }




 public function setSourceType($type)
 {
 $this->sourceType = $type;
 }




 public function getSourceType()
 {
 return $this->sourceType;
 }




 public function setSourceUrl($url)
 {
 $this->sourceUrl = $url;
 }




 public function getSourceUrl()
 {
 return $this->sourceUrl;
 }




 public function setSourceReference($reference)
 {
 $this->sourceReference = $reference;
 }




 public function getSourceReference()
 {
 return $this->sourceReference;
 }




 public function setSourceMirrors($mirrors)
 {
 $this->sourceMirrors = $mirrors;
 }




 public function getSourceMirrors()
 {
 return $this->sourceMirrors;
 }




 public function getSourceUrls()
 {
 return $this->getUrls($this->sourceUrl, $this->sourceMirrors, $this->sourceReference, $this->sourceType, 'source');
 }




 public function setDistType($type)
 {
 $this->distType = $type;
 }




 public function getDistType()
 {
 return $this->distType;
 }




 public function setDistUrl($url)
 {
 $this->distUrl = $url;
 }




 public function getDistUrl()
 {
 return $this->distUrl;
 }




 public function setDistReference($reference)
 {
 $this->distReference = $reference;
 }




 public function getDistReference()
 {
 return $this->distReference;
 }




 public function setDistSha1Checksum($sha1checksum)
 {
 $this->distSha1Checksum = $sha1checksum;
 }




 public function getDistSha1Checksum()
 {
 return $this->distSha1Checksum;
 }




 public function setDistMirrors($mirrors)
 {
 $this->distMirrors = $mirrors;
 }




 public function getDistMirrors()
 {
 return $this->distMirrors;
 }




 public function getDistUrls()
 {
 return $this->getUrls($this->distUrl, $this->distMirrors, $this->distReference, $this->distType, 'dist');
 }




 public function getVersion()
 {
 return $this->version;
 }




 public function getPrettyVersion()
 {
 return $this->prettyVersion;
 }






 public function setReleaseDate(\DateTime $releaseDate)
 {
 $this->releaseDate = $releaseDate;
 }




 public function getReleaseDate()
 {
 return $this->releaseDate;
 }






 public function setRequires(array $requires)
 {
 $this->requires = $requires;
 }




 public function getRequires()
 {
 return $this->requires;
 }






 public function setConflicts(array $conflicts)
 {
 $this->conflicts = $conflicts;
 }




 public function getConflicts()
 {
 return $this->conflicts;
 }






 public function setProvides(array $provides)
 {
 $this->provides = $provides;
 }




 public function getProvides()
 {
 return $this->provides;
 }






 public function setReplaces(array $replaces)
 {
 $this->replaces = $replaces;
 }




 public function getReplaces()
 {
 return $this->replaces;
 }






 public function setDevRequires(array $devRequires)
 {
 $this->devRequires = $devRequires;
 }




 public function getDevRequires()
 {
 return $this->devRequires;
 }






 public function setSuggests(array $suggests)
 {
 $this->suggests = $suggests;
 }




 public function getSuggests()
 {
 return $this->suggests;
 }






 public function setAutoload(array $autoload)
 {
 $this->autoload = $autoload;
 }




 public function getAutoload()
 {
 return $this->autoload;
 }






 public function setDevAutoload(array $devAutoload)
 {
 $this->devAutoload = $devAutoload;
 }




 public function getDevAutoload()
 {
 return $this->devAutoload;
 }






 public function setIncludePaths(array $includePaths)
 {
 $this->includePaths = $includePaths;
 }




 public function getIncludePaths()
 {
 return $this->includePaths;
 }






 public function setNotificationUrl($notificationUrl)
 {
 $this->notificationUrl = $notificationUrl;
 }




 public function getNotificationUrl()
 {
 return $this->notificationUrl;
 }






 public function setArchiveExcludes(array $excludes)
 {
 $this->archiveExcludes = $excludes;
 }




 public function getArchiveExcludes()
 {
 return $this->archiveExcludes;
 }








 public function replaceVersion($version, $prettyVersion)
 {
 $this->version = $version;
 $this->prettyVersion = $prettyVersion;

 $this->stability = VersionParser::parseStability($version);
 $this->dev = $this->stability === 'dev';
 }

 protected function getUrls($url, $mirrors, $ref, $type, $urlType)
 {
 if (!$url) {
 return array();
 }
 $urls = array($url);
 if ($mirrors) {
 foreach ($mirrors as $mirror) {
 if ($urlType === 'dist') {
 $mirrorUrl = ComposerMirror::processUrl($mirror['url'], $this->name, $this->version, $ref, $type);
 } elseif ($urlType === 'source' && $type === 'git') {
 $mirrorUrl = ComposerMirror::processGitUrl($mirror['url'], $this->name, $url, $type);
 } elseif ($urlType === 'source' && $type === 'hg') {
 $mirrorUrl = ComposerMirror::processHgUrl($mirror['url'], $this->name, $url, $type);
 }
 if (!in_array($mirrorUrl, $urls)) {
 $func = $mirror['preferred'] ? 'array_unshift' : 'array_push';
 $func($urls, $mirrorUrl);
 }
 }
 }

 return $urls;
 }
 }
 <?php











 namespace Composer\Package;

 use Composer\Repository\RepositoryInterface;






 interface PackageInterface
 {





 public function getName();






 public function getPrettyName();









 public function getNames();






 public function setId($id);






 public function getId();






 public function isDev();






 public function getType();






 public function getTargetDir();






 public function getExtra();






 public function setInstallationSource($type);






 public function getInstallationSource();






 public function getSourceType();






 public function getSourceUrl();






 public function getSourceUrls();






 public function getSourceReference();






 public function getSourceMirrors();






 public function getDistType();






 public function getDistUrl();






 public function getDistUrls();






 public function getDistReference();






 public function getDistSha1Checksum();






 public function getDistMirrors();






 public function getVersion();






 public function getPrettyVersion();









 public function getFullPrettyVersion($truncate = true);






 public function getReleaseDate();






 public function getStability();







 public function getRequires();







 public function getConflicts();







 public function getProvides();







 public function getReplaces();







 public function getDevRequires();







 public function getSuggests();











 public function getAutoload();











 public function getDevAutoload();







 public function getIncludePaths();






 public function setRepository(RepositoryInterface $repository);






 public function getRepository();






 public function getBinaries();






 public function getUniqueName();






 public function getNotificationUrl();






 public function __toString();






 public function getPrettyString();






 public function getArchiveExcludes();






 public function getTransportOptions();
 }
 <?php











 namespace Composer\Package;




 class RootAliasPackage extends AliasPackage implements RootPackageInterface
 {
 public function __construct(RootPackageInterface $aliasOf, $version, $prettyVersion)
 {
 parent::__construct($aliasOf, $version, $prettyVersion);
 }




 public function getAliases()
 {
 return $this->aliasOf->getAliases();
 }




 public function getMinimumStability()
 {
 return $this->aliasOf->getMinimumStability();
 }




 public function getStabilityFlags()
 {
 return $this->aliasOf->getStabilityFlags();
 }




 public function getReferences()
 {
 return $this->aliasOf->getReferences();
 }




 public function getPreferStable()
 {
 return $this->aliasOf->getPreferStable();
 }




 public function setRequires(array $require)
 {
 $this->requires = $this->replaceSelfVersionDependencies($require, 'requires');

 $this->aliasOf->setRequires($require);
 }




 public function setDevRequires(array $devRequire)
 {
 $this->devRequires = $this->replaceSelfVersionDependencies($devRequire, 'devRequires');

 $this->aliasOf->setDevRequires($devRequire);
 }

 public function __clone()
 {
 parent::__clone();
 $this->aliasOf = clone $this->aliasOf;
 }
 }
 <?php











 namespace Composer\Package;






 class RootPackage extends CompletePackage implements RootPackageInterface
 {
 protected $minimumStability = 'stable';
 protected $preferStable = false;
 protected $stabilityFlags = array();
 protected $references = array();
 protected $aliases = array();






 public function setMinimumStability($minimumStability)
 {
 $this->minimumStability = $minimumStability;
 }




 public function getMinimumStability()
 {
 return $this->minimumStability;
 }






 public function setStabilityFlags(array $stabilityFlags)
 {
 $this->stabilityFlags = $stabilityFlags;
 }




 public function getStabilityFlags()
 {
 return $this->stabilityFlags;
 }






 public function setPreferStable($preferStable)
 {
 $this->preferStable = $preferStable;
 }




 public function getPreferStable()
 {
 return $this->preferStable;
 }






 public function setReferences(array $references)
 {
 $this->references = $references;
 }




 public function getReferences()
 {
 return $this->references;
 }






 public function setAliases(array $aliases)
 {
 $this->aliases = $aliases;
 }




 public function getAliases()
 {
 return $this->aliases;
 }
 }
 <?php











 namespace Composer\Package;






 interface RootPackageInterface extends CompletePackageInterface
 {





 public function getAliases();






 public function getMinimumStability();








 public function getStabilityFlags();








 public function getReferences();






 public function getPreferStable();






 public function setRequires(array $requires);






 public function setDevRequires(array $devRequires);
 }
 <?php











 namespace Composer\Package\Version;

 use Composer\Package\PackageInterface;
 use Composer\Package\Link;
 use Composer\Package\LinkConstraint\EmptyConstraint;
 use Composer\Package\LinkConstraint\MultiConstraint;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Package\Loader\ArrayLoader;






 class VersionParser
 {
 private static $modifierRegex = '[._-]?(?:(stable|beta|b|RC|alpha|a|patch|pl|p)(?:[.-]?(\d+))?)?([.-]?dev)?';

 private static $stabilities = array(
 'stable', 'RC', 'beta', 'alpha', 'dev',
 );







 public static function parseStability($version)
 {
 $version = preg_replace('{#.+$}i', '', $version);

 if ('dev-' === substr($version, 0, 4) || '-dev' === substr($version, -4)) {
 return 'dev';
 }

 preg_match('{'.self::$modifierRegex.'$}i', strtolower($version), $match);
 if (!empty($match[3])) {
 return 'dev';
 }

 if (!empty($match[1])) {
 if ('beta' === $match[1] || 'b' === $match[1]) {
 return 'beta';
 }
 if ('alpha' === $match[1] || 'a' === $match[1]) {
 return 'alpha';
 }
 if ('rc' === $match[1]) {
 return 'RC';
 }
 }

 return 'stable';
 }

 public static function normalizeStability($stability)
 {
 $stability = strtolower($stability);

 return $stability === 'rc' ? 'RC' : $stability;
 }




 public static function formatVersion(PackageInterface $package, $truncate = true)
 {
 trigger_error(__METHOD__.' is deprecated. Use '.
 '\Composer\Package\PackageInterface::getFullPrettyVersion() instead', E_USER_DEPRECATED);

 return $package->getFullPrettyVersion($truncate);
 }









 public function normalize($version, $fullVersion = null)
 {
 $version = trim($version);
 if (null === $fullVersion) {
 $fullVersion = $version;
 }


 if (preg_match('{^([^,\s]+) +as +([^,\s]+)$}', $version, $match)) {
 $version = $match[1];
 }


 if (preg_match('{^([^,\s+]+)\+[^\s]+$}', $version, $match)) {
 $version = $match[1];
 }


 if (preg_match('{^(?:dev-)?(?:master|trunk|default)$}i', $version)) {
 return '9999999-dev';
 }

 if ('dev-' === strtolower(substr($version, 0, 4))) {
 return 'dev-'.substr($version, 4);
 }


 if (preg_match('{^v?(\d{1,3})(\.\d+)?(\.\d+)?(\.\d+)?'.self::$modifierRegex.'$}i', $version, $matches)) {
 $version = $matches[1]
 .(!empty($matches[2]) ? $matches[2] : '.0')
 .(!empty($matches[3]) ? $matches[3] : '.0')
 .(!empty($matches[4]) ? $matches[4] : '.0');
 $index = 5;
 } elseif (preg_match('{^v?(\d{4}(?:[.:-]?\d{2}){1,6}(?:[.:-]?\d{1,3})?)'.self::$modifierRegex.'$}i', $version, $matches)) { 
 $version = preg_replace('{\D}', '-', $matches[1]);
 $index = 2;
 } elseif (preg_match('{^v?(\d{4,})(\.\d+)?(\.\d+)?(\.\d+)?'.self::$modifierRegex.'$}i', $version, $matches)) {
 $version = $matches[1]
 .(!empty($matches[2]) ? $matches[2] : '.0')
 .(!empty($matches[3]) ? $matches[3] : '.0')
 .(!empty($matches[4]) ? $matches[4] : '.0');
 $index = 5;
 }


 if (isset($index)) {
 if (!empty($matches[$index])) {
 if ('stable' === $matches[$index]) {
 return $version;
 }
 $version .= '-' . $this->expandStability($matches[$index]) . (!empty($matches[$index + 1]) ? $matches[$index + 1] : '');
 }

 if (!empty($matches[$index + 2])) {
 $version .= '-dev';
 }

 return $version;
 }


 if (preg_match('{(.*?)[.-]?dev$}i', $version, $match)) {
 try {
 return $this->normalizeBranch($match[1]);
 } catch (\Exception $e) {
 }
 }

 $extraMessage = '';
 if (preg_match('{ +as +'.preg_quote($version).'$}', $fullVersion)) {
 $extraMessage = ' in "'.$fullVersion.'", the alias must be an exact version';
 } elseif (preg_match('{^'.preg_quote($version).' +as +}', $fullVersion)) {
 $extraMessage = ' in "'.$fullVersion.'", the alias source must be an exact version, if it is a branch name you should prefix it with dev-';
 }

 throw new \UnexpectedValueException('Invalid version string "'.$version.'"'.$extraMessage);
 }








 public function parseNumericAliasPrefix($branch)
 {
 if (preg_match('/^(?P<version>(\d+\\.)*\d+)(?:\.x)?-dev$/i', $branch, $matches)) {
 return $matches['version'].".";
 }

 return false;
 }







 public function normalizeBranch($name)
 {
 $name = trim($name);

 if (in_array($name, array('master', 'trunk', 'default'))) {
 return $this->normalize($name);
 }

 if (preg_match('#^v?(\d+)(\.(?:\d+|[xX*]))?(\.(?:\d+|[xX*]))?(\.(?:\d+|[xX*]))?$#i', $name, $matches)) {
 $version = '';
 for ($i = 1; $i < 5; $i++) {
 $version .= isset($matches[$i]) ? str_replace(array('*', 'X'), 'x', $matches[$i]) : '.x';
 }

 return str_replace('x', '9999999', $version).'-dev';
 }

 return 'dev-'.$name;
 }









 public function parseLinks($source, $sourceVersion, $description, $links)
 {
 trigger_error(__METHOD__.' is deprecated. Use '.
 '\Composer\Package\Loader\ArrayLoader::parseLinks() instead', E_USER_DEPRECATED);
 $loader = new ArrayLoader($this, false);

 return $loader->parseLinks($source, $sourceVersion, $description, $links);
 }







 public function parseConstraints($constraints)
 {
 $prettyConstraint = $constraints;

 if (preg_match('{^([^,\s]*?)@('.implode('|', self::$stabilities).')$}i', $constraints, $match)) {
 $constraints = empty($match[1]) ? '*' : $match[1];
 }

 if (preg_match('{^(dev-[^,\s@]+?|[^,\s@]+?\.x-dev)#.+$}i', $constraints, $match)) {
 $constraints = $match[1];
 }

 $orConstraints = preg_split('{\s*\|\|?\s*}', trim($constraints));
 $orGroups = array();
 foreach ($orConstraints as $constraints) {
 $andConstraints = preg_split('{(?<!^|as|[=>< ,]) *(?<!-)[, ](?!-) *(?!,|as|$)}', $constraints);
 if (count($andConstraints) > 1) {
 $constraintObjects = array();
 foreach ($andConstraints as $constraint) {
 foreach ($this->parseConstraint($constraint) as $parsedConstraint) {
 $constraintObjects[] = $parsedConstraint;
 }
 }
 } else {
 $constraintObjects = $this->parseConstraint($andConstraints[0]);
 }

 if (1 === count($constraintObjects)) {
 $constraint = $constraintObjects[0];
 } else {
 $constraint = new MultiConstraint($constraintObjects);
 }

 $orGroups[] = $constraint;
 }

 if (1 === count($orGroups)) {
 $constraint = $orGroups[0];
 } else {
 $constraint = new MultiConstraint($orGroups, false);
 }

 $constraint->setPrettyString($prettyConstraint);

 return $constraint;
 }

 private function parseConstraint($constraint)
 {
 if (preg_match('{^([^,\s]+?)@('.implode('|', self::$stabilities).')$}i', $constraint, $match)) {
 $constraint = $match[1];
 if ($match[2] !== 'stable') {
 $stabilityModifier = $match[2];
 }
 }

 if (preg_match('{^[xX*](\.[xX*])*$}i', $constraint)) {
 return array(new EmptyConstraint);
 }

 $versionRegex = '(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?'.self::$modifierRegex;


 
 
 
 
 if (preg_match('{^~>?'.$versionRegex.'$}i', $constraint, $matches)) {
 if (substr($constraint, 0, 2) === '~>') {
 throw new \UnexpectedValueException(
 'Could not parse version constraint '.$constraint.': '.
 'Invalid operator "~>", you probably meant to use the "~" operator'
 );
 }


 if (isset($matches[4]) && '' !== $matches[4]) {
 $position = 4;
 } elseif (isset($matches[3]) && '' !== $matches[3]) {
 $position = 3;
 } elseif (isset($matches[2]) && '' !== $matches[2]) {
 $position = 2;
 } else {
 $position = 1;
 }


 $stabilitySuffix = '';
 if (!empty($matches[5])) {
 $stabilitySuffix .= '-' . $this->expandStability($matches[5]) . (!empty($matches[6]) ? $matches[6] : '');
 }

 if (!empty($matches[7])) {
 $stabilitySuffix .= '-dev';
 }

 if (!$stabilitySuffix) {
 $stabilitySuffix = "-dev";
 }
 $lowVersion = $this->manipulateVersionString($matches, $position, 0) . $stabilitySuffix;
 $lowerBound = new VersionConstraint('>=', $lowVersion);


 
 $highPosition = max(1, $position - 1);
 $highVersion = $this->manipulateVersionString($matches, $highPosition, 1) . '-dev';
 $upperBound = new VersionConstraint('<', $highVersion);

 return array(
 $lowerBound,
 $upperBound
 );
 }


 if (preg_match('{^\^'.$versionRegex.'($)}i', $constraint, $matches)) {

 if ('0' !== $matches[1] || '' === $matches[2]) {
 $position = 1;
 } elseif ('0' !== $matches[2] || '' === $matches[3]) {
 $position = 2;
 } else {
 $position = 3;
 }


 $stabilitySuffix = '';
 if (empty($matches[5]) && empty($matches[7])) {
 $stabilitySuffix .= '-dev';
 }

 $lowVersion = $this->normalize(substr($constraint . $stabilitySuffix, 1));
 $lowerBound = new VersionConstraint('>=', $lowVersion);


 
 $highVersion = $this->manipulateVersionString($matches, $position, 1) . '-dev';
 $upperBound = new VersionConstraint('<', $highVersion);

 return array(
 $lowerBound,
 $upperBound
 );
 }


 if (preg_match('{^(\d+)(?:\.(\d+))?(?:\.(\d+))?\.[xX*]$}', $constraint, $matches)) {
 if (isset($matches[3]) && '' !== $matches[3]) {
 $position = 3;
 } elseif (isset($matches[2]) && '' !== $matches[2]) {
 $position = 2;
 } else {
 $position = 1;
 }

 $lowVersion = $this->manipulateVersionString($matches, $position) . "-dev";
 $highVersion = $this->manipulateVersionString($matches, $position, 1) . "-dev";

 if ($lowVersion === "0.0.0.0-dev") {
 return array(new VersionConstraint('<', $highVersion));
 }

 return array(
 new VersionConstraint('>=', $lowVersion),
 new VersionConstraint('<', $highVersion),
 );
 }


 if (preg_match('{^(?P<from>'.$versionRegex.') +- +(?P<to>'.$versionRegex.')($)}i', $constraint, $matches)) {

 $lowStabilitySuffix = '';
 if (empty($matches[6]) && empty($matches[8])) {
 $lowStabilitySuffix = '-dev';
 }

 $lowVersion = $this->normalize($matches['from']);
 $lowerBound = new VersionConstraint('>=', $lowVersion . $lowStabilitySuffix);

 $empty = function ($x) {
 return ($x === 0 || $x === "0") ? false : empty($x);
 };

 if ((!$empty($matches[11]) && !$empty($matches[12])) || !empty($matches[14]) || !empty($matches[16])) {
 $highVersion = $this->normalize($matches['to']);
 $upperBound = new VersionConstraint('<=', $highVersion);
 } else {
 $highMatch = array('', $matches[10], $matches[11], $matches[12], $matches[13]);
 $highVersion = $this->manipulateVersionString($highMatch, $empty($matches[11]) ? 1 : 2, 1) . '-dev';
 $upperBound = new VersionConstraint('<', $highVersion);
 }

 return array(
 $lowerBound,
 $upperBound
 );
 }


 if (preg_match('{^(<>|!=|>=?|<=?|==?)?\s*(.*)}', $constraint, $matches)) {
 try {
 $version = $this->normalize($matches[2]);

 if (!empty($stabilityModifier) && $this->parseStability($version) === 'stable') {
 $version .= '-' . $stabilityModifier;
 } elseif ('<' === $matches[1] || '>=' === $matches[1]) {
 if (!preg_match('/-' . self::$modifierRegex . '$/', strtolower($matches[2]))) {
 if (substr($matches[2], 0, 4) !== 'dev-') {
 $version .= '-dev';
 }
 }
 }

 return array(new VersionConstraint($matches[1] ?: '=', $version));
 } catch (\Exception $e) {
 }
 }

 $message = 'Could not parse version constraint '.$constraint;
 if (isset($e)) {
 $message .= ': '. $e->getMessage();
 }

 throw new \UnexpectedValueException($message);
 }












 private function manipulateVersionString($matches, $position, $increment = 0, $pad = '0')
 {
 for ($i = 4; $i > 0; $i--) {
 if ($i > $position) {
 $matches[$i] = $pad;
 } elseif ($i == $position && $increment) {
 $matches[$i] += $increment;

 if ($matches[$i] < 0) {
 $matches[$i] = $pad;
 $position--;


 if ($i == 1) {
 return;
 }
 }
 }
 }

 return $matches[1] . '.' . $matches[2] . '.' . $matches[3] . '.' . $matches[4];
 }

 private function expandStability($stability)
 {
 $stability = strtolower($stability);

 switch ($stability) {
 case 'a':
 return 'alpha';
 case 'b':
 return 'beta';
 case 'p':
 case 'pl':
 return 'patch';
 case 'rc':
 return 'RC';
 default:
 return $stability;
 }
 }







 public function parseNameVersionPairs(array $pairs)
 {
 $pairs = array_values($pairs);
 $result = array();

 for ($i = 0, $count = count($pairs); $i < $count; $i++) {
 $pair = preg_replace('{^([^=: ]+)[=: ](.*)$}', '$1 $2', trim($pairs[$i]));
 if (false === strpos($pair, ' ') && isset($pairs[$i + 1]) && false === strpos($pairs[$i + 1], '/')) {
 $pair .= ' '.$pairs[$i + 1];
 $i++;
 }

 if (strpos($pair, ' ')) {
 list($name, $version) = explode(" ", $pair, 2);
 $result[] = array('name' => $name, 'version' => $version);
 } else {
 $result[] = array('name' => $pair);
 }
 }

 return $result;
 }
 }
 <?php











 namespace Composer\Package\Version;

 use Composer\DependencyResolver\Pool;
 use Composer\Package\PackageInterface;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Dumper\ArrayDumper;







 class VersionSelector
 {
 private $pool;

 private $parser;

 public function __construct(Pool $pool)
 {
 $this->pool = $pool;
 }









 public function findBestCandidate($packageName, $targetPackageVersion = null)
 {
 $constraint = $targetPackageVersion ? $this->getParser()->parseConstraints($targetPackageVersion) : null;
 $candidates = $this->pool->whatProvides(strtolower($packageName), $constraint, true);

 if (!$candidates) {
 return false;
 }


 $package = reset($candidates);
 foreach ($candidates as $candidate) {
 if (version_compare($package->getVersion(), $candidate->getVersion(), '<')) {
 $package = $candidate;
 }
 }

 return $package;
 }
















 public function findRecommendedRequireVersion(PackageInterface $package)
 {
 $version = $package->getVersion();
 if (!$package->isDev()) {
 return $this->transformVersion($version, $package->getPrettyVersion(), $package->getStability());
 }

 $loader = new ArrayLoader($this->getParser());
 $dumper = new ArrayDumper();
 $extra = $loader->getBranchAlias($dumper->dump($package));
 if ($extra) {
 $extra = preg_replace('{^(\d+\.\d+\.\d+)(\.9999999)-dev$}', '$1.0', $extra, -1, $count);
 if ($count) {
 $extra = str_replace('.9999999', '.0', $extra);

 return $this->transformVersion($extra, $extra, 'dev');
 }
 }

 return $package->getPrettyVersion();
 }

 private function transformVersion($version, $prettyVersion, $stability)
 {

 
 $semanticVersionParts = explode('.', $version);


 if (count($semanticVersionParts) == 4 && preg_match('{^0\D?}', $semanticVersionParts[3])) {

 if ($semanticVersionParts[0] === '0') {
 unset($semanticVersionParts[3]);
 } else {
 unset($semanticVersionParts[2], $semanticVersionParts[3]);
 }
 $version = implode('.', $semanticVersionParts);
 } else {
 return $prettyVersion;
 }


 if ($stability != 'stable') {
 $version .= '@'.$stability;
 }


 return '^' . $version;
 }

 private function getParser()
 {
 if ($this->parser === null) {
 $this->parser = new VersionParser();
 }

 return $this->parser;
 }
 }
 <?php











 namespace Composer\Plugin;

 use Composer\EventDispatcher\Event;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;






 class CommandEvent extends Event
 {



 private $commandName;




 private $input;




 private $output;











 public function __construct($name, $commandName, $input, $output, array $args = array(), array $flags = array())
 {
 parent::__construct($name, $args, $flags);
 $this->commandName = $commandName;
 $this->input = $input;
 $this->output = $output;
 }






 public function getInput()
 {
 return $this->input;
 }






 public function getOutput()
 {
 return $this->output;
 }






 public function getCommandName()
 {
 return $this->commandName;
 }
 }
 <?php











 namespace Composer\Plugin;






 class PluginEvents
 {








 const COMMAND = 'command';









 const PRE_FILE_DOWNLOAD = 'pre-file-download';
 }
 <?php











 namespace Composer\Plugin;

 use Composer\Composer;
 use Composer\IO\IOInterface;






 interface PluginInterface
 {





 const PLUGIN_API_VERSION = '1.0.0';







 public function activate(Composer $composer, IOInterface $io);
 }
 <?php











 namespace Composer\Plugin;

 use Composer\Composer;
 use Composer\EventDispatcher\EventSubscriberInterface;
 use Composer\IO\IOInterface;
 use Composer\Package\Package;
 use Composer\Package\Version\VersionParser;
 use Composer\Repository\RepositoryInterface;
 use Composer\Package\AliasPackage;
 use Composer\Package\PackageInterface;
 use Composer\Package\Link;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\DependencyResolver\Pool;







 class PluginManager
 {
 protected $composer;
 protected $io;
 protected $globalComposer;
 protected $versionParser;

 protected $plugins = array();
 protected $registeredPlugins = array();

 private static $classCounter = 0;








 public function __construct(IOInterface $io, Composer $composer, Composer $globalComposer = null)
 {
 $this->io = $io;
 $this->composer = $composer;
 $this->globalComposer = $globalComposer;
 $this->versionParser = new VersionParser();
 }




 public function loadInstalledPlugins()
 {
 $repo = $this->composer->getRepositoryManager()->getLocalRepository();
 $globalRepo = $this->globalComposer ? $this->globalComposer->getRepositoryManager()->getLocalRepository() : null;
 if ($repo) {
 $this->loadRepository($repo);
 }
 if ($globalRepo) {
 $this->loadRepository($globalRepo);
 }
 }






 public function addPlugin(PluginInterface $plugin)
 {
 if ($this->io->isDebug()) {
 $this->io->writeError('Loading plugin '.get_class($plugin));
 }
 $this->plugins[] = $plugin;
 $plugin->activate($this->composer, $this->io);

 if ($plugin instanceof EventSubscriberInterface) {
 $this->composer->getEventDispatcher()->addSubscriber($plugin);
 }
 }






 public function getPlugins()
 {
 return $this->plugins;
 }












 public function loadRepository(RepositoryInterface $repo)
 {
 foreach ($repo->getPackages() as $package) { 
 if ($package instanceof AliasPackage) {
 continue;
 }
 if ('composer-plugin' === $package->getType()) {
 $requiresComposer = null;
 foreach ($package->getRequires() as $link) { 
 if ('composer-plugin-api' === $link->getTarget()) {
 $requiresComposer = $link->getConstraint();
 break;
 }
 }

 if (!$requiresComposer) {
 throw new \RuntimeException("Plugin ".$package->getName()." is missing a require statement for a version of the composer-plugin-api package.");
 }

 $currentPluginApiVersion = $this->getPluginApiVersion();
 $currentPluginApiConstraint = new VersionConstraint('==', $this->versionParser->normalize($currentPluginApiVersion));

 if (!$requiresComposer->matches($currentPluginApiConstraint)) {
 $this->io->writeError('<warning>The "' . $package->getName() . '" plugin was skipped because it requires a Plugin API version ("' . $requiresComposer->getPrettyString() . '") that does not match your Composer installation ("' . $currentPluginApiVersion . '"). You may need to run composer update with the "--no-plugins" option.</warning>');
 continue;
 }

 $this->registerPackage($package);


 } elseif ('composer-installer' === $package->getType()) {
 $this->registerPackage($package);
 }
 }
 }










 protected function collectDependencies(Pool $pool, array $collected, PackageInterface $package)
 {
 $requires = array_merge(
 $package->getRequires(),
 $package->getDevRequires()
 );

 foreach ($requires as $requireLink) {
 $requiredPackage = $this->lookupInstalledPackage($pool, $requireLink);
 if ($requiredPackage && !isset($collected[$requiredPackage->getName()])) {
 $collected[$requiredPackage->getName()] = $requiredPackage;
 $collected = $this->collectDependencies($pool, $collected, $requiredPackage);
 }
 }

 return $collected;
 }











 protected function lookupInstalledPackage(Pool $pool, Link $link)
 {
 $packages = $pool->whatProvides($link->getTarget(), $link->getConstraint());

 return (!empty($packages)) ? $packages[0] : null;
 }












 public function registerPackage(PackageInterface $package, $failOnMissingClasses = false)
 {
 $oldInstallerPlugin = ($package->getType() === 'composer-installer');

 if (in_array($package->getName(), $this->registeredPlugins)) {
 return;
 }

 $extra = $package->getExtra();
 if (empty($extra['class'])) {
 throw new \UnexpectedValueException('Error while installing '.$package->getPrettyName().', composer-plugin packages should have a class defined in their extra key to be usable.');
 }
 $classes = is_array($extra['class']) ? $extra['class'] : array($extra['class']);

 $localRepo = $this->composer->getRepositoryManager()->getLocalRepository();
 $globalRepo = $this->globalComposer ? $this->globalComposer->getRepositoryManager()->getLocalRepository() : null;

 $pool = new Pool('dev');
 $pool->addRepository($localRepo);
 if ($globalRepo) {
 $pool->addRepository($globalRepo);
 }

 $autoloadPackages = array($package->getName() => $package);
 $autoloadPackages = $this->collectDependencies($pool, $autoloadPackages, $package);

 $generator = $this->composer->getAutoloadGenerator();
 $autoloads = array();
 foreach ($autoloadPackages as $autoloadPackage) {
 $downloadPath = $this->getInstallPath($autoloadPackage, ($globalRepo && $globalRepo->hasPackage($autoloadPackage)));
 $autoloads[] = array($autoloadPackage, $downloadPath);
 }

 $map = $generator->parseAutoloads($autoloads, new Package('dummy', '1.0.0.0', '1.0.0'));
 $classLoader = $generator->createLoader($map);
 $classLoader->register();

 foreach ($classes as $class) {
 if (class_exists($class, false)) {
 $code = file_get_contents($classLoader->findFile($class));
 $code = preg_replace('{^(\s*)class\s+(\S+)}mi', '$1class $2_composer_tmp'.self::$classCounter, $code);
 eval('?>'.$code);
 $class .= '_composer_tmp'.self::$classCounter;
 self::$classCounter++;
 }

 if ($oldInstallerPlugin) {
 $installer = new $class($this->io, $this->composer);
 $this->composer->getInstallationManager()->addInstaller($installer);
 } elseif (class_exists($class)) {
 $plugin = new $class();
 $this->addPlugin($plugin);
 $this->registeredPlugins[] = $package->getName();
 } elseif ($failOnMissingClasses) {
 throw new \UnexpectedValueException('Plugin '.$package->getName().' could not be initialized, class not found: '.$class);
 }
 }
 }









 public function getInstallPath(PackageInterface $package, $global = false)
 {
 if (!$global) {
 return $this->composer->getInstallationManager()->getInstallPath($package);
 }

 return $this->globalComposer->getInstallationManager()->getInstallPath($package);
 }






 protected function getPluginApiVersion()
 {
 return PluginInterface::PLUGIN_API_VERSION;
 }
 }
 <?php











 namespace Composer\Plugin;

 use Composer\EventDispatcher\Event;
 use Composer\Util\RemoteFilesystem;






 class PreFileDownloadEvent extends Event
 {



 private $rfs;




 private $processedUrl;








 public function __construct($name, RemoteFilesystem $rfs, $processedUrl)
 {
 parent::__construct($name);
 $this->rfs = $rfs;
 $this->processedUrl = $processedUrl;
 }






 public function getRemoteFilesystem()
 {
 return $this->rfs;
 }






 public function setRemoteFilesystem(RemoteFilesystem $rfs)
 {
 $this->rfs = $rfs;
 }






 public function getProcessedUrl()
 {
 return $this->processedUrl;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\AliasPackage;
 use Composer\Package\PackageInterface;
 use Composer\Package\CompletePackageInterface;
 use Composer\Package\Version\VersionParser;
 use Composer\Package\LinkConstraint\LinkConstraintInterface;
 use Composer\Package\LinkConstraint\VersionConstraint;






 class ArrayRepository implements RepositoryInterface
 {

 protected $packages;

 public function __construct(array $packages = array())
 {
 foreach ($packages as $package) {
 $this->addPackage($package);
 }
 }




 public function findPackage($name, $constraint)
 {
 $name = strtolower($name);

 if (!$constraint instanceof LinkConstraintInterface) {
 $versionParser = new VersionParser();
 $constraint = $versionParser->parseConstraints($constraint);
 }

 foreach ($this->getPackages() as $package) {
 if ($name === $package->getName()) {
 $pkgConstraint = new VersionConstraint('==', $package->getVersion());
 if ($constraint->matches($pkgConstraint)) {
 return $package;
 }
 }
 }
 }




 public function findPackages($name, $constraint = null)
 {

 $name = strtolower($name);
 $packages = array();

 if (null !== $constraint && !$constraint instanceof LinkConstraintInterface) {
 $versionParser = new VersionParser();
 $constraint = $versionParser->parseConstraints($constraint);
 }

 foreach ($this->getPackages() as $package) {
 if ($name === $package->getName()) {
 $pkgConstraint = new VersionConstraint('==', $package->getVersion());
 if (null === $constraint || $constraint->matches($pkgConstraint)) {
 $packages[] = $package;
 }
 }
 }

 return $packages;
 }




 public function search($query, $mode = 0)
 {
 $regex = '{(?:'.implode('|', preg_split('{\s+}', $query)).')}i';

 $matches = array();
 foreach ($this->getPackages() as $package) {
 $name = $package->getName();
 if (isset($matches[$name])) {
 continue;
 }
 if (preg_match($regex, $name)
 || ($mode === self::SEARCH_FULLTEXT && $package instanceof CompletePackageInterface && preg_match($regex, implode(' ', (array) $package->getKeywords()) . ' ' . $package->getDescription()))
 ) {
 $matches[$name] = array(
 'name' => $package->getPrettyName(),
 'description' => $package->getDescription(),
 );
 }
 }

 return array_values($matches);
 }




 public function hasPackage(PackageInterface $package)
 {
 $packageId = $package->getUniqueName();

 foreach ($this->getPackages() as $repoPackage) {
 if ($packageId === $repoPackage->getUniqueName()) {
 return true;
 }
 }

 return false;
 }






 public function addPackage(PackageInterface $package)
 {
 if (null === $this->packages) {
 $this->initialize();
 }
 $package->setRepository($this);
 $this->packages[] = $package;

 if ($package instanceof AliasPackage) {
 $aliasedPackage = $package->getAliasOf();
 if (null === $aliasedPackage->getRepository()) {
 $this->addPackage($aliasedPackage);
 }
 }
 }

 protected function createAliasPackage(PackageInterface $package, $alias, $prettyAlias)
 {
 return new AliasPackage($package instanceof AliasPackage ? $package->getAliasOf() : $package, $alias, $prettyAlias);
 }






 public function removePackage(PackageInterface $package)
 {
 $packageId = $package->getUniqueName();

 foreach ($this->getPackages() as $key => $repoPackage) {
 if ($packageId === $repoPackage->getUniqueName()) {
 array_splice($this->packages, $key, 1);

 return;
 }
 }
 }




 public function getPackages()
 {
 if (null === $this->packages) {
 $this->initialize();
 }

 return $this->packages;
 }






 public function count()
 {
 return count($this->packages);
 }




 protected function initialize()
 {
 $this->packages = array();
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\IO\IOInterface;
 use Composer\Json\JsonFile;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Loader\LoaderInterface;




 class ArtifactRepository extends ArrayRepository
 {

 protected $loader;

 protected $lookup;

 public function __construct(array $repoConfig, IOInterface $io)
 {
 if (!extension_loaded('zip')) {
 throw new \RuntimeException('The artifact repository requires PHP\'s zip extension');
 }

 $this->loader = new ArrayLoader();
 $this->lookup = $repoConfig['url'];
 $this->io = $io;
 }

 protected function initialize()
 {
 parent::initialize();

 $this->scanDirectory($this->lookup);
 }

 private function scanDirectory($path)
 {
 $io = $this->io;

 $directory = new \RecursiveDirectoryIterator($path);
 $iterator = new \RecursiveIteratorIterator($directory);
 $regex = new \RegexIterator($iterator, '/^.+\.(zip|phar)$/i');
 foreach ($regex as $file) {

 if (!$file->isFile()) {
 continue;
 }

 $package = $this->getComposerInformation($file);
 if (!$package) {
 if ($io->isVerbose()) {
 $io->writeError("File <comment>{$file->getBasename()}</comment> doesn't seem to hold a package");
 }
 continue;
 }

 if ($io->isVerbose()) {
 $template = 'Found package <info>%s</info> (<comment>%s</comment>) in file <info>%s</info>';
 $io->writeError(sprintf($template, $package->getName(), $package->getPrettyVersion(), $file->getBasename()));
 }

 $this->addPackage($package);
 }
 }








 private function locateFile(\ZipArchive $zip, $filename)
 {
 $indexOfShortestMatch = false;
 $lengthOfShortestMatch = -1;

 for ($i = 0; $i < $zip->numFiles; $i++) {
 $stat = $zip->statIndex($i);
 if (strcmp(basename($stat['name']), $filename) === 0) {
 $directoryName = dirname($stat['name']);
 if ($directoryName == '.') {

 
 return $i;
 }

 if (strpos($directoryName, '\\') !== false ||
 strpos($directoryName, '/') !== false) {

 continue;
 }

 $length = strlen($stat['name']);
 if ($indexOfShortestMatch == false || $length < $lengthOfShortestMatch) {

 $contents = $zip->getFromIndex($i);
 if ($contents !== false) {
 $indexOfShortestMatch = $i;
 $lengthOfShortestMatch = $length;
 }
 }
 }
 }

 return $indexOfShortestMatch;
 }

 private function getComposerInformation(\SplFileInfo $file)
 {
 $zip = new \ZipArchive();
 $zip->open($file->getPathname());

 if (0 == $zip->numFiles) {
 return false;
 }

 $foundFileIndex = $this->locateFile($zip, 'composer.json');
 if (false === $foundFileIndex) {
 return false;
 }

 $configurationFileName = $zip->getNameIndex($foundFileIndex);

 $composerFile = "zip://{$file->getPathname()}#$configurationFileName";
 $json = file_get_contents($composerFile);

 $package = JsonFile::parseJson($json, $composerFile);
 $package['dist'] = array(
 'type' => 'zip',
 'url' => $file->getPathname(),
 'shasum' => sha1_file($file->getRealPath())
 );

 $package = $this->loader->load($package);

 return $package;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\PackageInterface;
 use Composer\Package\AliasPackage;
 use Composer\Package\Version\VersionParser;
 use Composer\DependencyResolver\Pool;
 use Composer\Json\JsonFile;
 use Composer\Cache;
 use Composer\Config;
 use Composer\IO\IOInterface;
 use Composer\Util\RemoteFilesystem;
 use Composer\Plugin\PluginEvents;
 use Composer\Plugin\PreFileDownloadEvent;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Package\LinkConstraint\LinkConstraintInterface;
 use Composer\Package\LinkConstraint\VersionConstraint;




 class ComposerRepository extends ArrayRepository
 {
 protected $config;
 protected $options;
 protected $url;
 protected $baseUrl;
 protected $io;
 protected $rfs;
 protected $cache;
 protected $notifyUrl;
 protected $searchUrl;
 protected $hasProviders = false;
 protected $providersUrl;
 protected $lazyProvidersUrl;
 protected $providerListing;
 protected $providers = array();
 protected $providersByUid = array();
 protected $loader;
 protected $rootAliases;
 protected $allowSslDowngrade = false;
 protected $eventDispatcher;
 protected $sourceMirrors;
 protected $distMirrors;
 private $degradedMode = false;
 private $rootData;

 public function __construct(array $repoConfig, IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null)
 {
 if (!preg_match('{^[\w.]+\??://}', $repoConfig['url'])) {

 $repoConfig['url'] = 'http://'.$repoConfig['url'];
 }
 $repoConfig['url'] = rtrim($repoConfig['url'], '/');

 if ('https?' === substr($repoConfig['url'], 0, 6)) {
 $repoConfig['url'] = (extension_loaded('openssl') ? 'https' : 'http') . substr($repoConfig['url'], 6);
 }

 $urlBits = parse_url($repoConfig['url']);
 if ($urlBits === false || empty($urlBits['scheme'])) {
 throw new \UnexpectedValueException('Invalid url given for Composer repository: '.$repoConfig['url']);
 }

 if (!isset($repoConfig['options'])) {
 $repoConfig['options'] = array();
 }
 if (isset($repoConfig['allow_ssl_downgrade']) && true === $repoConfig['allow_ssl_downgrade']) {
 $this->allowSslDowngrade = true;
 }

 $this->config = $config;
 $this->options = $repoConfig['options'];
 $this->url = $repoConfig['url'];
 $this->baseUrl = rtrim(preg_replace('{^(.*)(?:/[^/\\]+.json)?(?:[?#].*)?$}', '$1', $this->url), '/');
 $this->io = $io;
 $this->cache = new Cache($io, $config->get('cache-repo-dir').'/'.preg_replace('{[^a-z0-9.]}i', '-', $this->url), 'a-z0-9.$');
 $this->loader = new ArrayLoader();
 $this->rfs = new RemoteFilesystem($this->io, $this->config, $this->options);
 $this->eventDispatcher = $eventDispatcher;
 }

 public function setRootAliases(array $rootAliases)
 {
 $this->rootAliases = $rootAliases;
 }




 public function findPackage($name, $constraint)
 {
 if (!$this->hasProviders()) {
 return parent::findPackage($name, $constraint);
 }

 $name = strtolower($name);
 if (!$constraint instanceof LinkConstraintInterface) {
 $versionParser = new VersionParser();
 $constraint = $versionParser->parseConstraints($constraint);
 }

 foreach ($this->getProviderNames() as $providerName) {
 if ($name === $providerName) {
 $packages = $this->whatProvides(new Pool('dev'), $providerName);
 foreach ($packages as $package) {
 if ($name === $package->getName()) {
 $pkgConstraint = new VersionConstraint('==', $package->getVersion());
 if ($constraint->matches($pkgConstraint)) {
 return $package;
 }
 }
 }
 }
 }
 }




 public function findPackages($name, $constraint = null)
 {
 if (!$this->hasProviders()) {
 return parent::findPackages($name, $constraint);
 }

 $name = strtolower($name);

 if (null !== $constraint && !$constraint instanceof LinkConstraintInterface) {
 $versionParser = new VersionParser();
 $constraint = $versionParser->parseConstraints($constraint);
 }

 $packages = array();

 foreach ($this->getProviderNames() as $providerName) {
 if ($name === $providerName) {
 $candidates = $this->whatProvides(new Pool('dev'), $providerName);
 foreach ($candidates as $package) {
 if ($name === $package->getName()) {
 $pkgConstraint = new VersionConstraint('==', $package->getVersion());
 if (null === $constraint || $constraint->matches($pkgConstraint)) {
 $packages[] = $package;
 }
 }
 }
 }
 }

 return $packages;
 }

 public function getPackages()
 {
 if ($this->hasProviders()) {
 throw new \LogicException('Composer repositories that have providers can not load the complete list of packages, use getProviderNames instead.');
 }

 return parent::getPackages();
 }




 public function search($query, $mode = 0)
 {
 $this->loadRootServerFile();

 if ($this->searchUrl && $mode === self::SEARCH_FULLTEXT) {
 $url = str_replace('%query%', $query, $this->searchUrl);

 $hostname = parse_url($url, PHP_URL_HOST) ?: $url;
 $json = $this->rfs->getContents($hostname, $url, false);
 $results = JsonFile::parseJson($json, $url);

 return $results['results'];
 }

 if ($this->hasProviders()) {
 $results = array();
 $regex = '{(?:'.implode('|', preg_split('{\s+}', $query)).')}i';

 foreach ($this->getProviderNames() as $name) {
 if (preg_match($regex, $name)) {
 $results[] = array('name' => $name);
 }
 }

 return $results;
 }

 return parent::search($query, $mode);
 }

 public function getProviderNames()
 {
 $this->loadRootServerFile();

 if (null === $this->providerListing) {
 $this->loadProviderListings($this->loadRootServerFile());
 }

 if ($this->lazyProvidersUrl) {

 return array();
 }

 if ($this->providersUrl) {
 return array_keys($this->providerListing);
 }


 $providers = array();
 foreach (array_keys($this->providerListing) as $provider) {
 $providers[] = substr($provider, 2, -5);
 }

 return $providers;
 }

 protected function configurePackageTransportOptions(PackageInterface $package)
 {
 foreach ($package->getDistUrls() as $url) {
 if (strpos($url, $this->baseUrl) === 0) {
 $package->setTransportOptions($this->options);

 return;
 }
 }
 }

 public function hasProviders()
 {
 $this->loadRootServerFile();

 return $this->hasProviders;
 }

 public function resetPackageIds()
 {
 foreach ($this->providersByUid as $package) {
 if ($package instanceof AliasPackage) {
 $package->getAliasOf()->setId(-1);
 }
 $package->setId(-1);
 }
 }

 public function whatProvides(Pool $pool, $name)
 {
 if (isset($this->providers[$name])) {
 return $this->providers[$name];
 }


 if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $name) || '__root__' === $name) {
 return array();
 }

 if (null === $this->providerListing) {
 $this->loadProviderListings($this->loadRootServerFile());
 }

 if ($this->lazyProvidersUrl && !isset($this->providerListing[$name])) {
 $hash = null;
 $url = str_replace('%package%', $name, $this->lazyProvidersUrl);
 $cacheKey = false;
 } elseif ($this->providersUrl) {

 if (!isset($this->providerListing[$name])) {
 return array();
 }

 $hash = $this->providerListing[$name]['sha256'];
 $url = str_replace(array('%package%', '%hash%'), array($name, $hash), $this->providersUrl);
 $cacheKey = 'provider-'.strtr($name, '/', '$').'.json';
 } else {

 $url = 'p/'.$name.'.json';


 if (!isset($this->providerListing[$url])) {
 return array();
 }
 $hash = $this->providerListing[$url]['sha256'];
 $cacheKey = null;
 }

 if ($cacheKey && $this->cache->sha256($cacheKey) === $hash) {
 $packages = json_decode($this->cache->read($cacheKey), true);
 } else {
 $packages = $this->fetchFile($url, $cacheKey, $hash);
 }

 $this->providers[$name] = array();
 foreach ($packages['packages'] as $versions) {
 foreach ($versions as $version) {

 if (isset($this->providersByUid[$version['uid']])) {

 if (!isset($this->providers[$name][$version['uid']])) {

 if ($this->providersByUid[$version['uid']] instanceof AliasPackage) {
 $this->providers[$name][$version['uid']] = $this->providersByUid[$version['uid']]->getAliasOf();
 $this->providers[$name][$version['uid'].'-alias'] = $this->providersByUid[$version['uid']];
 } else {
 $this->providers[$name][$version['uid']] = $this->providersByUid[$version['uid']];
 }

 if (isset($this->providersByUid[$version['uid'].'-root'])) {
 $this->providers[$name][$version['uid'].'-root'] = $this->providersByUid[$version['uid'].'-root'];
 }
 }
 } else {
 if (!$pool->isPackageAcceptable(strtolower($version['name']), VersionParser::parseStability($version['version']))) {
 continue;
 }


 $package = $this->createPackage($version, 'Composer\Package\Package');
 $package->setRepository($this);

 if ($package instanceof AliasPackage) {
 $aliased = $package->getAliasOf();
 $aliased->setRepository($this);

 $this->providers[$name][$version['uid']] = $aliased;
 $this->providers[$name][$version['uid'].'-alias'] = $package;


 $this->providersByUid[$version['uid']] = $package;
 } else {
 $this->providers[$name][$version['uid']] = $package;
 $this->providersByUid[$version['uid']] = $package;
 }


 unset($rootAliasData);

 if (isset($this->rootAliases[$package->getName()][$package->getVersion()])) {
 $rootAliasData = $this->rootAliases[$package->getName()][$package->getVersion()];
 } elseif ($package instanceof AliasPackage && isset($this->rootAliases[$package->getName()][$package->getAliasOf()->getVersion()])) {
 $rootAliasData = $this->rootAliases[$package->getName()][$package->getAliasOf()->getVersion()];
 }

 if (isset($rootAliasData)) {
 $alias = $this->createAliasPackage($package, $rootAliasData['alias_normalized'], $rootAliasData['alias']);
 $alias->setRepository($this);

 $this->providers[$name][$version['uid'].'-root'] = $alias;
 $this->providersByUid[$version['uid'].'-root'] = $alias;
 }
 }
 }
 }

 return $this->providers[$name];
 }




 protected function initialize()
 {
 parent::initialize();

 $repoData = $this->loadDataFromServer();

 foreach ($repoData as $package) {
 $this->addPackage($this->createPackage($package, 'Composer\Package\CompletePackage'));
 }
 }






 public function addPackage(PackageInterface $package)
 {
 parent::addPackage($package);
 $this->configurePackageTransportOptions($package);
 }

 protected function loadRootServerFile()
 {
 if (null !== $this->rootData) {
 return $this->rootData;
 }

 if (!extension_loaded('openssl') && 'https' === substr($this->url, 0, 5)) {
 throw new \RuntimeException('You must enable the openssl extension in your php.ini to load information from '.$this->url);
 }

 $jsonUrlParts = parse_url($this->url);

 if (isset($jsonUrlParts['path']) && false !== strpos($jsonUrlParts['path'], '.json')) {
 $jsonUrl = $this->url;
 } else {
 $jsonUrl = $this->url . '/packages.json';
 }

 $data = $this->fetchFile($jsonUrl, 'packages.json');

 if (!empty($data['notify-batch'])) {
 $this->notifyUrl = $this->canonicalizeUrl($data['notify-batch']);
 } elseif (!empty($data['notify_batch'])) {

 $this->notifyUrl = $this->canonicalizeUrl($data['notify_batch']);
 } elseif (!empty($data['notify'])) {
 $this->notifyUrl = $this->canonicalizeUrl($data['notify']);
 }

 if (!empty($data['search'])) {
 $this->searchUrl = $this->canonicalizeUrl($data['search']);
 }

 if (!empty($data['mirrors'])) {
 foreach ($data['mirrors'] as $mirror) {
 if (!empty($mirror['git-url'])) {
 $this->sourceMirrors['git'][] = array('url' => $mirror['git-url'], 'preferred' => !empty($mirror['preferred']));
 }
 if (!empty($mirror['hg-url'])) {
 $this->sourceMirrors['hg'][] = array('url' => $mirror['hg-url'], 'preferred' => !empty($mirror['preferred']));
 }
 if (!empty($mirror['dist-url'])) {
 $this->distMirrors[] = array('url' => $mirror['dist-url'], 'preferred' => !empty($mirror['preferred']));
 }
 }
 }

 if (!empty($data['warning'])) {
 $this->io->writeError('<warning>Warning from '.$this->url.': '.$data['warning'].'</warning>');
 }

 if (!empty($data['providers-lazy-url'])) {
 $this->lazyProvidersUrl = $this->canonicalizeUrl($data['providers-lazy-url']);
 $this->hasProviders = true;
 }

 if ($this->allowSslDowngrade) {
 $this->url = str_replace('https://', 'http://', $this->url);
 $this->baseUrl = str_replace('https://', 'http://', $this->baseUrl);
 }

 if (!empty($data['providers-url'])) {
 $this->providersUrl = $this->canonicalizeUrl($data['providers-url']);
 $this->hasProviders = true;
 }

 if (!empty($data['providers']) || !empty($data['providers-includes'])) {
 $this->hasProviders = true;
 }

 return $this->rootData = $data;
 }

 protected function canonicalizeUrl($url)
 {
 if ('/' === $url[0]) {
 return preg_replace('{(https?://[^/]+).*}i', '$1' . $url, $this->url);
 }

 return $url;
 }

 protected function loadDataFromServer()
 {
 $data = $this->loadRootServerFile();

 return $this->loadIncludes($data);
 }

 protected function loadProviderListings($data)
 {
 if (isset($data['providers'])) {
 if (!is_array($this->providerListing)) {
 $this->providerListing = array();
 }
 $this->providerListing = array_merge($this->providerListing, $data['providers']);
 }

 if ($this->providersUrl && isset($data['provider-includes'])) {
 $includes = $data['provider-includes'];
 foreach ($includes as $include => $metadata) {
 $url = $this->baseUrl . '/' . str_replace('%hash%', $metadata['sha256'], $include);
 $cacheKey = str_replace(array('%hash%','$'), '', $include);
 if ($this->cache->sha256($cacheKey) === $metadata['sha256']) {
 $includedData = json_decode($this->cache->read($cacheKey), true);
 } else {
 $includedData = $this->fetchFile($url, $cacheKey, $metadata['sha256']);
 }

 $this->loadProviderListings($includedData);
 }
 } elseif (isset($data['providers-includes'])) {

 $includes = $data['providers-includes'];
 foreach ($includes as $include => $metadata) {
 if ($this->cache->sha256($include) === $metadata['sha256']) {
 $includedData = json_decode($this->cache->read($include), true);
 } else {
 $includedData = $this->fetchFile($include, null, $metadata['sha256']);
 }

 $this->loadProviderListings($includedData);
 }
 }
 }

 protected function loadIncludes($data)
 {
 $packages = array();


 if (!isset($data['packages']) && !isset($data['includes'])) {
 foreach ($data as $pkg) {
 foreach ($pkg['versions'] as $metadata) {
 $packages[] = $metadata;
 }
 }

 return $packages;
 }

 if (isset($data['packages'])) {
 foreach ($data['packages'] as $package => $versions) {
 foreach ($versions as $version => $metadata) {
 $packages[] = $metadata;
 }
 }
 }

 if (isset($data['includes'])) {
 foreach ($data['includes'] as $include => $metadata) {
 if ($this->cache->sha1($include) === $metadata['sha1']) {
 $includedData = json_decode($this->cache->read($include), true);
 } else {
 $includedData = $this->fetchFile($include);
 }
 $packages = array_merge($packages, $this->loadIncludes($includedData));
 }
 }

 return $packages;
 }

 protected function createPackage(array $data, $class)
 {
 try {
 if (!isset($data['notification-url'])) {
 $data['notification-url'] = $this->notifyUrl;
 }

 $package = $this->loader->load($data, 'Composer\Package\CompletePackage');
 if (isset($this->sourceMirrors[$package->getSourceType()])) {
 $package->setSourceMirrors($this->sourceMirrors[$package->getSourceType()]);
 }
 $package->setDistMirrors($this->distMirrors);
 $this->configurePackageTransportOptions($package);

 return $package;
 } catch (\Exception $e) {
 throw new \RuntimeException('Could not load package '.(isset($data['name']) ? $data['name'] : json_encode($data)).' in '.$this->url.': ['.get_class($e).'] '.$e->getMessage(), 0, $e);
 }
 }

 protected function fetchFile($filename, $cacheKey = null, $sha256 = null)
 {
 if (null === $cacheKey) {
 $cacheKey = $filename;
 $filename = $this->baseUrl.'/'.$filename;
 }

 $retries = 3;
 while ($retries--) {
 try {
 $preFileDownloadEvent = new PreFileDownloadEvent(PluginEvents::PRE_FILE_DOWNLOAD, $this->rfs, $filename);
 if ($this->eventDispatcher) {
 $this->eventDispatcher->dispatch($preFileDownloadEvent->getName(), $preFileDownloadEvent);
 }

 $hostname = parse_url($filename, PHP_URL_HOST) ?: $filename;
 $json = $preFileDownloadEvent->getRemoteFilesystem()->getContents($hostname, $filename, false);
 if ($sha256 && $sha256 !== hash('sha256', $json)) {
 if ($retries) {
 usleep(100000);

 continue;
 }


 throw new RepositorySecurityException('The contents of '.$filename.' do not match its signature. This should indicate a man-in-the-middle attack. Try running composer again and report this if you think it is a mistake.');
 }
 $data = JsonFile::parseJson($json, $filename);
 if ($cacheKey) {
 $this->cache->write($cacheKey, $json);
 }

 break;
 } catch (\Exception $e) {
 if ($retries) {
 usleep(100000);
 continue;
 }

 if ($e instanceof RepositorySecurityException) {
 throw $e;
 }

 if ($cacheKey && ($contents = $this->cache->read($cacheKey))) {
 if (!$this->degradedMode) {
 $this->io->writeError('<warning>'.$e->getMessage().'</warning>');
 $this->io->writeError('<warning>'.$this->url.' could not be fully loaded, package information was loaded from the local cache and may be out of date</warning>');
 }
 $this->degradedMode = true;
 $data = JsonFile::parseJson($contents, $this->cache->getRoot().$cacheKey);

 break;
 }

 throw $e;
 }
 }

 return $data;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\PackageInterface;






 class CompositeRepository implements RepositoryInterface
 {




 private $repositories;





 public function __construct(array $repositories)
 {
 $this->repositories = array();
 foreach ($repositories as $repo) {
 $this->addRepository($repo);
 }
 }






 public function getRepositories()
 {
 return $this->repositories;
 }




 public function hasPackage(PackageInterface $package)
 {
 foreach ($this->repositories as $repository) {

 if ($repository->hasPackage($package)) {
 return true;
 }
 }

 return false;
 }




 public function findPackage($name, $constraint)
 {
 foreach ($this->repositories as $repository) {

 $package = $repository->findPackage($name, $constraint);
 if (null !== $package) {
 return $package;
 }
 }

 return null;
 }




 public function findPackages($name, $constraint = null)
 {
 $packages = array();
 foreach ($this->repositories as $repository) {

 $packages[] = $repository->findPackages($name, $constraint);
 }

 return $packages ? call_user_func_array('array_merge', $packages) : array();
 }




 public function search($query, $mode = 0)
 {
 $matches = array();
 foreach ($this->repositories as $repository) {

 $matches[] = $repository->search($query, $mode);
 }

 return $matches ? call_user_func_array('array_merge', $matches) : array();
 }




 public function getPackages()
 {
 $packages = array();
 foreach ($this->repositories as $repository) {

 $packages[] = $repository->getPackages();
 }

 return $packages ? call_user_func_array('array_merge', $packages) : array();
 }




 public function removePackage(PackageInterface $package)
 {
 foreach ($this->repositories as $repository) {

 $repository->removePackage($package);
 }
 }




 public function count()
 {
 $total = 0;
 foreach ($this->repositories as $repository) {

 $total += $repository->count();
 }

 return $total;
 }





 public function addRepository(RepositoryInterface $repository)
 {
 if ($repository instanceof self) {
 foreach ($repository->getRepositories() as $repo) {
 $this->addRepository($repo);
 }
 } else {
 $this->repositories[] = $repository;
 }
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Json\JsonFile;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Dumper\ArrayDumper;







 class FilesystemRepository extends WritableArrayRepository
 {
 private $file;






 public function __construct(JsonFile $repositoryFile)
 {
 $this->file = $repositoryFile;
 }




 protected function initialize()
 {
 parent::initialize();

 if (!$this->file->exists()) {
 return;
 }

 try {
 $packages = $this->file->read();

 if (!is_array($packages)) {
 throw new \UnexpectedValueException('Could not parse package list from the repository');
 }
 } catch (\Exception $e) {
 throw new InvalidRepositoryException('Invalid repository data in '.$this->file->getPath().', packages could not be loaded: ['.get_class($e).'] '.$e->getMessage());
 }

 $loader = new ArrayLoader(null, true);
 foreach ($packages as $packageData) {
 $package = $loader->load($packageData);
 $this->addPackage($package);
 }
 }

 public function reload()
 {
 $this->packages = null;
 $this->initialize();
 }




 public function write()
 {
 $data = array();
 $dumper = new ArrayDumper();

 foreach ($this->getCanonicalPackages() as $package) {
 $data[] = $dumper->dump($package);
 }

 $this->file->write($data);
 }
 }
 <?php











 namespace Composer\Repository;








 class InstalledArrayRepository extends WritableArrayRepository implements InstalledRepositoryInterface
 {
 }
 <?php











 namespace Composer\Repository;






 class InstalledFilesystemRepository extends FilesystemRepository implements InstalledRepositoryInterface
 {
 }
 <?php











 namespace Composer\Repository;








 interface InstalledRepositoryInterface extends WritableRepositoryInterface
 {
 }
 <?php











 namespace Composer\Repository;






 class InvalidRepositoryException extends \Exception
 {
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Loader\ValidatingArrayLoader;






 class PackageRepository extends ArrayRepository
 {
 private $config;






 public function __construct(array $config)
 {
 $this->config = $config['package'];


 if (!is_numeric(key($this->config))) {
 $this->config = array($this->config);
 }
 }




 protected function initialize()
 {
 parent::initialize();

 $loader = new ValidatingArrayLoader(new ArrayLoader, false);
 foreach ($this->config as $package) {
 try {
 $package = $loader->load($package);
 } catch (\Exception $e) {
 throw new InvalidRepositoryException('A repository of type "package" contains an invalid package definition: '.$e->getMessage()."\n\nInvalid package definition:\n".json_encode($package));
 }

 $this->addPackage($package);
 }
 }
 }
 <?php











 namespace Composer\Repository\Pear;

 use Composer\Util\RemoteFilesystem;








 abstract class BaseChannelReader
 {



 const CHANNEL_NS = 'http://pear.php.net/channel-1.0';
 const ALL_CATEGORIES_NS = 'http://pear.php.net/dtd/rest.allcategories';
 const CATEGORY_PACKAGES_INFO_NS = 'http://pear.php.net/dtd/rest.categorypackageinfo';
 const ALL_PACKAGES_NS = 'http://pear.php.net/dtd/rest.allpackages';
 const ALL_RELEASES_NS = 'http://pear.php.net/dtd/rest.allreleases';
 const PACKAGE_INFO_NS = 'http://pear.php.net/dtd/rest.package';


 private $rfs;

 protected function __construct(RemoteFilesystem $rfs)
 {
 $this->rfs = $rfs;
 }









 protected function requestContent($origin, $path)
 {
 $url = rtrim($origin, '/') . '/' . ltrim($path, '/');
 $content = $this->rfs->getContents($origin, $url, false);
 if (!$content) {
 throw new \UnexpectedValueException('The PEAR channel at ' . $url . ' did not respond.');
 }

 return $content;
 }









 protected function requestXml($origin, $path)
 {

 $xml = simplexml_load_string($this->requestContent($origin, $path), "SimpleXMLElement", LIBXML_NOERROR);

 if (false == $xml) {
 $url = rtrim($origin, '/') . '/' . ltrim($path, '/');
 throw new \UnexpectedValueException(sprintf('The PEAR channel at ' . $origin . ' is broken. (Invalid XML at file `%s`)', $path));
 }

 return $xml;
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class ChannelInfo
 {
 private $name;
 private $alias;
 private $packages;






 public function __construct($name, $alias, array $packages)
 {
 $this->name = $name;
 $this->alias = $alias;
 $this->packages = $packages;
 }






 public function getName()
 {
 return $this->name;
 }






 public function getAlias()
 {
 return $this->alias;
 }






 public function getPackages()
 {
 return $this->packages;
 }
 }
 <?php











 namespace Composer\Repository\Pear;

 use Composer\Util\RemoteFilesystem;








 class ChannelReader extends BaseChannelReader
 {

 private $readerMap;

 public function __construct(RemoteFilesystem $rfs)
 {
 parent::__construct($rfs);

 $rest10reader = new ChannelRest10Reader($rfs);
 $rest11reader = new ChannelRest11Reader($rfs);

 $this->readerMap = array(
 'REST1.3' => $rest11reader,
 'REST1.2' => $rest11reader,
 'REST1.1' => $rest11reader,
 'REST1.0' => $rest10reader,
 );
 }








 public function read($url)
 {
 $xml = $this->requestXml($url, "/channel.xml");

 $channelName = (string) $xml->name;
 $channelSummary = (string) $xml->summary;
 $channelAlias = (string) $xml->suggestedalias;

 $supportedVersions = array_keys($this->readerMap);
 $selectedRestVersion = $this->selectRestVersion($xml, $supportedVersions);
 if (!$selectedRestVersion) {
 throw new \UnexpectedValueException(sprintf('PEAR repository %s does not supports any of %s protocols.', $url, implode(', ', $supportedVersions)));
 }

 $reader = $this->readerMap[$selectedRestVersion['version']];
 $packageDefinitions = $reader->read($selectedRestVersion['baseUrl']);

 return new ChannelInfo($channelName, $channelAlias, $packageDefinitions);
 }








 private function selectRestVersion($channelXml, $supportedVersions)
 {
 $channelXml->registerXPathNamespace('ns', self::CHANNEL_NS);

 foreach ($supportedVersions as $version) {
 $xpathTest = "ns:servers/ns:primary/ns:rest/ns:baseurl[@type='{$version}']";
 $testResult = $channelXml->xpath($xpathTest);
 if (count($testResult) > 0) {
 return array('version' => $version, 'baseUrl' => (string) $testResult[0]);
 }
 }

 return null;
 }
 }
 <?php











 namespace Composer\Repository\Pear;

 use Composer\Downloader\TransportException;












 class ChannelRest10Reader extends BaseChannelReader
 {
 private $dependencyReader;

 public function __construct($rfs)
 {
 parent::__construct($rfs);

 $this->dependencyReader = new PackageDependencyParser();
 }








 public function read($baseUrl)
 {
 return $this->readPackages($baseUrl);
 }








 private function readPackages($baseUrl)
 {
 $result = array();

 $xmlPath = '/p/packages.xml';
 $xml = $this->requestXml($baseUrl, $xmlPath);
 $xml->registerXPathNamespace('ns', self::ALL_PACKAGES_NS);
 foreach ($xml->xpath('ns:p') as $node) {
 $packageName = (string) $node;
 $packageInfo = $this->readPackage($baseUrl, $packageName);
 $result[] = $packageInfo;
 }

 return $result;
 }









 private function readPackage($baseUrl, $packageName)
 {
 $xmlPath = '/p/' . strtolower($packageName) . '/info.xml';
 $xml = $this->requestXml($baseUrl, $xmlPath);
 $xml->registerXPathNamespace('ns', self::PACKAGE_INFO_NS);

 $channelName = (string) $xml->c;
 $packageName = (string) $xml->n;
 $license = (string) $xml->l;
 $shortDescription = (string) $xml->s;
 $description = (string) $xml->d;

 return new PackageInfo(
 $channelName,
 $packageName,
 $license,
 $shortDescription,
 $description,
 $this->readPackageReleases($baseUrl, $packageName)
 );
 }










 private function readPackageReleases($baseUrl, $packageName)
 {
 $result = array();

 try {
 $xmlPath = '/r/' . strtolower($packageName) . '/allreleases.xml';
 $xml = $this->requestXml($baseUrl, $xmlPath);
 $xml->registerXPathNamespace('ns', self::ALL_RELEASES_NS);
 foreach ($xml->xpath('ns:r') as $node) {
 $releaseVersion = (string) $node->v;
 $releaseStability = (string) $node->s;

 try {
 $result[$releaseVersion] = new ReleaseInfo(
 $releaseStability,
 $this->readPackageReleaseDependencies($baseUrl, $packageName, $releaseVersion)
 );
 } catch (TransportException $exception) {
 if ($exception->getCode() != 404) {
 throw $exception;
 }
 }
 }
 } catch (TransportException $exception) {
 if ($exception->getCode() != 404) {
 throw $exception;
 }
 }

 return $result;
 }










 private function readPackageReleaseDependencies($baseUrl, $packageName, $version)
 {
 $dependencyReader = new PackageDependencyParser();

 $depthPath = '/r/' . strtolower($packageName) . '/deps.' . $version . '.txt';
 $content = $this->requestContent($baseUrl, $depthPath);
 $dependencyArray = unserialize($content);
 $result = $dependencyReader->buildDependencyInfo($dependencyArray);

 return $result;
 }
 }
 <?php











 namespace Composer\Repository\Pear;










 class ChannelRest11Reader extends BaseChannelReader
 {
 private $dependencyReader;

 public function __construct($rfs)
 {
 parent::__construct($rfs);

 $this->dependencyReader = new PackageDependencyParser();
 }








 public function read($baseUrl)
 {
 return $this->readChannelPackages($baseUrl);
 }








 private function readChannelPackages($baseUrl)
 {
 $result = array();

 $xml = $this->requestXml($baseUrl, "/c/categories.xml");
 $xml->registerXPathNamespace('ns', self::ALL_CATEGORIES_NS);
 foreach ($xml->xpath('ns:c') as $node) {
 $categoryName = (string) $node;
 $categoryPackages = $this->readCategoryPackages($baseUrl, $categoryName);
 $result = array_merge($result, $categoryPackages);
 }

 return $result;
 }









 private function readCategoryPackages($baseUrl, $categoryName)
 {
 $result = array();

 $categoryPath = '/c/'.urlencode($categoryName).'/packagesinfo.xml';
 $xml = $this->requestXml($baseUrl, $categoryPath);
 $xml->registerXPathNamespace('ns', self::CATEGORY_PACKAGES_INFO_NS);
 foreach ($xml->xpath('ns:pi') as $node) {
 $packageInfo = $this->parsePackage($node);
 $result[] = $packageInfo;
 }

 return $result;
 }







 private function parsePackage($packageInfo)
 {
 $packageInfo->registerXPathNamespace('ns', self::CATEGORY_PACKAGES_INFO_NS);
 $channelName = (string) $packageInfo->p->c;
 $packageName = (string) $packageInfo->p->n;
 $license = (string) $packageInfo->p->l;
 $shortDescription = (string) $packageInfo->p->s;
 $description = (string) $packageInfo->p->d;

 $dependencies = array();
 foreach ($packageInfo->xpath('ns:deps') as $node) {
 $dependencyVersion = (string) $node->v;
 $dependencyArray = unserialize((string) $node->d);

 $dependencyInfo = $this->dependencyReader->buildDependencyInfo($dependencyArray);

 $dependencies[$dependencyVersion] = $dependencyInfo;
 }

 $releases = array();
 $releasesInfo = $packageInfo->xpath('ns:a/ns:r');
 if ($releasesInfo) {
 foreach ($releasesInfo as $node) {
 $releaseVersion = (string) $node->v;
 $releaseStability = (string) $node->s;
 $releases[$releaseVersion] = new ReleaseInfo(
 $releaseStability,
 isset($dependencies[$releaseVersion]) ? $dependencies[$releaseVersion] : new DependencyInfo(array(), array())
 );
 }
 }

 return new PackageInfo(
 $channelName,
 $packageName,
 $license,
 $shortDescription,
 $description,
 $releases
 );
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class DependencyConstraint
 {
 private $type;
 private $constraint;
 private $channelName;
 private $packageName;







 public function __construct($type, $constraint, $channelName, $packageName)
 {
 $this->type = $type;
 $this->constraint = $constraint;
 $this->channelName = $channelName;
 $this->packageName = $packageName;
 }

 public function getChannelName()
 {
 return $this->channelName;
 }

 public function getConstraint()
 {
 return $this->constraint;
 }

 public function getPackageName()
 {
 return $this->packageName;
 }

 public function getType()
 {
 return $this->type;
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class DependencyInfo
 {
 private $requires;
 private $optionals;





 public function __construct($requires, $optionals)
 {
 $this->requires = $requires;
 $this->optionals = $optionals;
 }




 public function getRequires()
 {
 return $this->requires;
 }




 public function getOptionals()
 {
 return $this->optionals;
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class PackageDependencyParser
 {






 public function buildDependencyInfo($depArray)
 {
 if (!is_array($depArray)) {
 return new DependencyInfo(array(), array());
 }
 if (!$this->isHash($depArray)) {
 return new DependencyInfo($this->buildDependency10Info($depArray), array());
 }

 return $this->buildDependency20Info($depArray);
 }













 private function buildDependency10Info($depArray)
 {
 static $dep10toOperatorMap = array('has' => '==', 'eq' => '==', 'ge' => '>=', 'gt' => '>', 'le' => '<=', 'lt' => '<', 'not' => '!=');

 $result = array();

 foreach ($depArray as $depItem) {
 if (empty($depItem['rel']) || !array_key_exists($depItem['rel'], $dep10toOperatorMap)) {

 continue;
 }

 $depType = !empty($depItem['optional']) && 'yes' == $depItem['optional']
 ? 'optional'
 : 'required';
 $depType = 'not' == $depItem['rel']
 ? 'conflicts'
 : $depType;

 $depVersion = !empty($depItem['version']) ? $this->parseVersion($depItem['version']) : '*';


 $depVersionConstraint = ('has' == $depItem['rel'] || 'not' == $depItem['rel']) && '*' == $depVersion
 ? '*'
 : $dep10toOperatorMap[$depItem['rel']] . $depVersion;

 switch ($depItem['type']) {
 case 'php':
 $depChannelName = 'php';
 $depPackageName = '';
 break;
 case 'pkg':
 $depChannelName = !empty($depItem['channel']) ? $depItem['channel'] : 'pear.php.net';
 $depPackageName = $depItem['name'];
 break;
 case 'ext':
 $depChannelName = 'ext';
 $depPackageName = $depItem['name'];
 break;
 case 'os':
 case 'sapi':
 $depChannelName = '';
 $depPackageName = '';
 break;
 default:
 $depChannelName = '';
 $depPackageName = '';
 break;
 }

 if ('' != $depChannelName) {
 $result[] = new DependencyConstraint(
 $depType,
 $depVersionConstraint,
 $depChannelName,
 $depPackageName
 );
 }
 }

 return $result;
 }







 private function buildDependency20Info($depArray)
 {
 $result = array();
 $optionals = array();
 $defaultOptionals = array();
 foreach ($depArray as $depType => $depTypeGroup) {
 if (!is_array($depTypeGroup)) {
 continue;
 }
 if ('required' == $depType || 'optional' == $depType) {
 foreach ($depTypeGroup as $depItemType => $depItem) {
 switch ($depItemType) {
 case 'php':
 $result[] = new DependencyConstraint(
 $depType,
 $this->parse20VersionConstraint($depItem),
 'php',
 ''
 );
 break;
 case 'package':
 $deps = $this->buildDepPackageConstraints($depItem, $depType);
 $result = array_merge($result, $deps);
 break;
 case 'extension':
 $deps = $this->buildDepExtensionConstraints($depItem, $depType);
 $result = array_merge($result, $deps);
 break;
 case 'subpackage':
 $deps = $this->buildDepPackageConstraints($depItem, 'replaces');
 $defaultOptionals += $deps;
 break;
 case 'os':
 case 'pearinstaller':
 break;
 default:
 break;
 }
 }
 } elseif ('group' == $depType) {
 if ($this->isHash($depTypeGroup)) {
 $depTypeGroup = array($depTypeGroup);
 }

 foreach ($depTypeGroup as $depItem) {
 $groupName = $depItem['attribs']['name'];
 if (!isset($optionals[$groupName])) {
 $optionals[$groupName] = array();
 }

 if (isset($depItem['subpackage'])) {
 $optionals[$groupName] += $this->buildDepPackageConstraints($depItem['subpackage'], 'replaces');
 } else {
 $result += $this->buildDepPackageConstraints($depItem['package'], 'optional');
 }
 }
 }
 }

 if (count($defaultOptionals) > 0) {
 $optionals['*'] = $defaultOptionals;
 }

 return new DependencyInfo($result, $optionals);
 }








 private function buildDepExtensionConstraints($depItem, $depType)
 {
 if ($this->isHash($depItem)) {
 $depItem = array($depItem);
 }

 $result = array();
 foreach ($depItem as $subDepItem) {
 $depChannelName = 'ext';
 $depPackageName = $subDepItem['name'];
 $depVersionConstraint = $this->parse20VersionConstraint($subDepItem);

 $result[] = new DependencyConstraint(
 $depType,
 $depVersionConstraint,
 $depChannelName,
 $depPackageName
 );
 }

 return $result;
 }








 private function buildDepPackageConstraints($depItem, $depType)
 {
 if ($this->isHash($depItem)) {
 $depItem = array($depItem);
 }

 $result = array();
 foreach ($depItem as $subDepItem) {
 $depChannelName = $subDepItem['channel'];
 $depPackageName = $subDepItem['name'];
 $depVersionConstraint = $this->parse20VersionConstraint($subDepItem);
 if (isset($subDepItem['conflicts'])) {
 $depType = 'conflicts';
 }

 $result[] = new DependencyConstraint(
 $depType,
 $depVersionConstraint,
 $depChannelName,
 $depPackageName
 );
 }

 return $result;
 }







 private function parse20VersionConstraint(array $data)
 {
 static $dep20toOperatorMap = array('has' => '==', 'min' => '>=', 'max' => '<=', 'exclude' => '!=');

 $versions = array();
 $values = array_intersect_key($data, $dep20toOperatorMap);
 if (0 == count($values)) {
 return '*';
 }
 if (isset($values['min']) && isset($values['exclude']) && $data['min'] == $data['exclude']) {
 $versions[] = '>' . $this->parseVersion($values['min']);
 } elseif (isset($values['max']) && isset($values['exclude']) && $data['max'] == $data['exclude']) {
 $versions[] = '<' . $this->parseVersion($values['max']);
 } else {
 foreach ($values as $op => $version) {
 if ('exclude' == $op && is_array($version)) {
 foreach ($version as $versionPart) {
 $versions[] = $dep20toOperatorMap[$op] . $this->parseVersion($versionPart);
 }
 } else {
 $versions[] = $dep20toOperatorMap[$op] . $this->parseVersion($version);
 }
 }
 }

 return implode(',', $versions);
 }







 private function parseVersion($version)
 {
 if (preg_match('{^v?(\d{1,3})(\.\d+)?(\.\d+)?(\.\d+)?}i', $version, $matches)) {
 $version = $matches[1]
 .(!empty($matches[2]) ? $matches[2] : '.0')
 .(!empty($matches[3]) ? $matches[3] : '.0')
 .(!empty($matches[4]) ? $matches[4] : '.0');

 return $version;
 }

 return null;
 }







 private function isHash(array $array)
 {
 return !array_key_exists(1, $array) && !array_key_exists(0, $array);
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class PackageInfo
 {
 private $channelName;
 private $packageName;
 private $license;
 private $shortDescription;
 private $description;
 private $releases;









 public function __construct($channelName, $packageName, $license, $shortDescription, $description, $releases)
 {
 $this->channelName = $channelName;
 $this->packageName = $packageName;
 $this->license = $license;
 $this->shortDescription = $shortDescription;
 $this->description = $description;
 $this->releases = $releases;
 }




 public function getChannelName()
 {
 return $this->channelName;
 }




 public function getPackageName()
 {
 return $this->packageName;
 }




 public function getDescription()
 {
 return $this->description;
 }




 public function getShortDescription()
 {
 return $this->shortDescription;
 }




 public function getLicense()
 {
 return $this->license;
 }




 public function getReleases()
 {
 return $this->releases;
 }
 }
 <?php











 namespace Composer\Repository\Pear;






 class ReleaseInfo
 {
 private $stability;
 private $dependencyInfo;





 public function __construct($stability, $dependencyInfo)
 {
 $this->stability = $stability;
 $this->dependencyInfo = $dependencyInfo;
 }




 public function getDependencyInfo()
 {
 return $this->dependencyInfo;
 }




 public function getStability()
 {
 return $this->stability;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\IO\IOInterface;
 use Composer\Package\Version\VersionParser;
 use Composer\Repository\Pear\ChannelReader;
 use Composer\Package\CompletePackage;
 use Composer\Repository\Pear\ChannelInfo;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Package\Link;
 use Composer\Package\LinkConstraint\VersionConstraint;
 use Composer\Util\RemoteFilesystem;
 use Composer\Config;










 class PearRepository extends ArrayRepository
 {
 private $url;
 private $io;
 private $rfs;
 private $versionParser;




 private $vendorAlias;

 public function __construct(array $repoConfig, IOInterface $io, Config $config, EventDispatcher $dispatcher = null, RemoteFilesystem $rfs = null)
 {
 if (!preg_match('{^https?://}', $repoConfig['url'])) {
 $repoConfig['url'] = 'http://'.$repoConfig['url'];
 }

 $urlBits = parse_url($repoConfig['url']);
 if (empty($urlBits['scheme']) || empty($urlBits['host'])) {
 throw new \UnexpectedValueException('Invalid url given for PEAR repository: '.$repoConfig['url']);
 }

 $this->url = rtrim($repoConfig['url'], '/');
 $this->io = $io;
 $this->rfs = $rfs ?: new RemoteFilesystem($this->io, $config);
 $this->vendorAlias = isset($repoConfig['vendor-alias']) ? $repoConfig['vendor-alias'] : null;
 $this->versionParser = new VersionParser();
 }

 protected function initialize()
 {
 parent::initialize();

 $this->io->writeError('Initializing PEAR repository '.$this->url);

 $reader = new ChannelReader($this->rfs);
 try {
 $channelInfo = $reader->read($this->url);
 } catch (\Exception $e) {
 $this->io->writeError('<warning>PEAR repository from '.$this->url.' could not be loaded. '.$e->getMessage().'</warning>');

 return;
 }
 $packages = $this->buildComposerPackages($channelInfo, $this->versionParser);
 foreach ($packages as $package) {
 $this->addPackage($package);
 }
 }








 private function buildComposerPackages(ChannelInfo $channelInfo, VersionParser $versionParser)
 {
 $result = array();
 foreach ($channelInfo->getPackages() as $packageDefinition) {
 foreach ($packageDefinition->getReleases() as $version => $releaseInfo) {
 try {
 $normalizedVersion = $versionParser->normalize($version);
 } catch (\UnexpectedValueException $e) {
 if ($this->io->isVerbose()) {
 $this->io->writeError('Could not load '.$packageDefinition->getPackageName().' '.$version.': '.$e->getMessage());
 }
 continue;
 }

 $composerPackageName = $this->buildComposerPackageName($packageDefinition->getChannelName(), $packageDefinition->getPackageName());


 
 $urlBits = parse_url($this->url);
 $scheme = (isset($urlBits['scheme']) && 'https' === $urlBits['scheme'] && extension_loaded('openssl')) ? 'https' : 'http';
 $distUrl = "{$scheme}://{$packageDefinition->getChannelName()}/get/{$packageDefinition->getPackageName()}-{$version}.tgz";

 $requires = array();
 $suggests = array();
 $conflicts = array();
 $replaces = array();


 
 if ($channelInfo->getName() == $packageDefinition->getChannelName()) {
 $composerPackageAlias = $this->buildComposerPackageName($channelInfo->getAlias(), $packageDefinition->getPackageName());
 $aliasConstraint = new VersionConstraint('==', $normalizedVersion);
 $replaces[] = new Link($composerPackageName, $composerPackageAlias, $aliasConstraint, 'replaces', (string) $aliasConstraint);
 }


 if (!empty($this->vendorAlias)
 && ($this->vendorAlias != 'pear-'.$channelInfo->getAlias() || $channelInfo->getName() != $packageDefinition->getChannelName())
 ) {
 $composerPackageAlias = "{$this->vendorAlias}/{$packageDefinition->getPackageName()}";
 $aliasConstraint = new VersionConstraint('==', $normalizedVersion);
 $replaces[] = new Link($composerPackageName, $composerPackageAlias, $aliasConstraint, 'replaces', (string) $aliasConstraint);
 }

 foreach ($releaseInfo->getDependencyInfo()->getRequires() as $dependencyConstraint) {
 $dependencyPackageName = $this->buildComposerPackageName($dependencyConstraint->getChannelName(), $dependencyConstraint->getPackageName());
 $constraint = $versionParser->parseConstraints($dependencyConstraint->getConstraint());
 $link = new Link($composerPackageName, $dependencyPackageName, $constraint, $dependencyConstraint->getType(), $dependencyConstraint->getConstraint());
 switch ($dependencyConstraint->getType()) {
 case 'required':
 $requires[] = $link;
 break;
 case 'conflicts':
 $conflicts[] = $link;
 break;
 case 'replaces':
 $replaces[] = $link;
 break;
 }
 }

 foreach ($releaseInfo->getDependencyInfo()->getOptionals() as $group => $dependencyConstraints) {
 foreach ($dependencyConstraints as $dependencyConstraint) {
 $dependencyPackageName = $this->buildComposerPackageName($dependencyConstraint->getChannelName(), $dependencyConstraint->getPackageName());
 $suggests[$group.'-'.$dependencyPackageName] = $dependencyConstraint->getConstraint();
 }
 }

 $package = new CompletePackage($composerPackageName, $normalizedVersion, $version);
 $package->setType('pear-library');
 $package->setDescription($packageDefinition->getDescription());
 $package->setLicense(array($packageDefinition->getLicense()));
 $package->setDistType('file');
 $package->setDistUrl($distUrl);
 $package->setAutoload(array('classmap' => array('')));
 $package->setIncludePaths(array('/'));
 $package->setRequires($requires);
 $package->setConflicts($conflicts);
 $package->setSuggests($suggests);
 $package->setReplaces($replaces);
 $result[] = $package;
 }
 }

 return $result;
 }

 private function buildComposerPackageName($channelName, $packageName)
 {
 if ('php' === $channelName) {
 return "php";
 }
 if ('ext' === $channelName) {
 return "ext-{$packageName}";
 }

 return "pear-{$channelName}/{$packageName}";
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Config;
 use Composer\Package\PackageInterface;
 use Composer\Package\CompletePackage;
 use Composer\Package\Version\VersionParser;
 use Composer\Plugin\PluginInterface;




 class PlatformRepository extends ArrayRepository
 {
 const PLATFORM_PACKAGE_REGEX = '{^(?:php(?:-64bit)?|hhvm|(?:ext|lib)-[^/]+)$}i';








 private $overrides = array();

 public function __construct(array $packages = array(), array $overrides = array())
 {
 foreach ($overrides as $name => $version) {
 $this->overrides[strtolower($name)] = array('name' => $name, 'version' => $version);
 }
 parent::__construct($packages);
 }

 protected function initialize()
 {
 parent::initialize();

 $versionParser = new VersionParser();


 
 foreach ($this->overrides as $override) {

 if (!preg_match(self::PLATFORM_PACKAGE_REGEX, $override['name'])) {
 throw new \InvalidArgumentException('Invalid platform package name in config.platform: '.$override['name']);
 }

 $version = $versionParser->normalize($override['version']);
 $package = new CompletePackage($override['name'], $version, $override['version']);
 $package->setDescription('Overridden virtual platform package '.$override['name']);
 parent::addPackage($package);
 }

 $prettyVersion = PluginInterface::PLUGIN_API_VERSION;
 $version = $versionParser->normalize($prettyVersion);
 $composerPluginApi = new CompletePackage('composer-plugin-api', $version, $prettyVersion);
 $composerPluginApi->setDescription('The Composer Plugin API');
 $this->addPackage($composerPluginApi);

 try {
 $prettyVersion = PHP_VERSION;
 $version = $versionParser->normalize($prettyVersion);
 } catch (\UnexpectedValueException $e) {
 $prettyVersion = preg_replace('#^([^~+-]+).*$#', '$1', PHP_VERSION);
 $version = $versionParser->normalize($prettyVersion);
 }

 $php = new CompletePackage('php', $version, $prettyVersion);
 $php->setDescription('The PHP interpreter');
 $this->addPackage($php);

 if (PHP_INT_SIZE === 8) {
 $php64 = new CompletePackage('php-64bit', $version, $prettyVersion);
 $php64->setDescription('The PHP interpreter (64bit)');
 $this->addPackage($php64);
 }

 $loadedExtensions = get_loaded_extensions();


 foreach ($loadedExtensions as $name) {
 if (in_array($name, array('standard', 'Core'))) {
 continue;
 }

 $reflExt = new \ReflectionExtension($name);
 try {
 $prettyVersion = $reflExt->getVersion();
 $version = $versionParser->normalize($prettyVersion);
 } catch (\UnexpectedValueException $e) {
 $prettyVersion = '0';
 $version = $versionParser->normalize($prettyVersion);
 }

 $packageName = $this->buildPackageName($name);
 $ext = new CompletePackage($packageName, $version, $prettyVersion);
 $ext->setDescription('The '.$name.' PHP extension');
 $this->addPackage($ext);
 }


 
 
 foreach ($loadedExtensions as $name) {
 $prettyVersion = null;
 switch ($name) {
 case 'curl':
 $curlVersion = curl_version();
 $prettyVersion = $curlVersion['version'];
 break;

 case 'iconv':
 $prettyVersion = ICONV_VERSION;
 break;

 case 'intl':
 $name = 'ICU';
 if (defined('INTL_ICU_VERSION')) {
 $prettyVersion = INTL_ICU_VERSION;
 } else {
 $reflector = new \ReflectionExtension('intl');

 ob_start();
 $reflector->info();
 $output = ob_get_clean();

 preg_match('/^ICU version => (.*)$/m', $output, $matches);
 $prettyVersion = $matches[1];
 }

 break;

 case 'libxml':
 $prettyVersion = LIBXML_DOTTED_VERSION;
 break;

 case 'openssl':
 $prettyVersion = preg_replace_callback('{^(?:OpenSSL\s*)?([0-9.]+)([a-z]?).*}', function ($match) {
 return $match[1] . (empty($match[2]) ? '' : '.'.(ord($match[2]) - 96));
 }, OPENSSL_VERSION_TEXT);
 break;

 case 'pcre':
 $prettyVersion = preg_replace('{^(\S+).*}', '$1', PCRE_VERSION);
 break;

 case 'uuid':
 $prettyVersion = phpversion('uuid');
 break;

 case 'xsl':
 $prettyVersion = LIBXSLT_DOTTED_VERSION;
 break;

 default:

 continue 2;
 }

 try {
 $version = $versionParser->normalize($prettyVersion);
 } catch (\UnexpectedValueException $e) {
 continue;
 }

 $lib = new CompletePackage('lib-'.$name, $version, $prettyVersion);
 $lib->setDescription('The '.$name.' PHP library');
 $this->addPackage($lib);
 }

 if (defined('HHVM_VERSION')) {
 try {
 $prettyVersion = HHVM_VERSION;
 $version = $versionParser->normalize($prettyVersion);
 } catch (\UnexpectedValueException $e) {
 $prettyVersion = preg_replace('#^([^~+-]+).*$#', '$1', HHVM_VERSION);
 $version = $versionParser->normalize($prettyVersion);
 }

 $hhvm = new CompletePackage('hhvm', $version, $prettyVersion);
 $hhvm->setDescription('The HHVM Runtime (64bit)');
 $this->addPackage($hhvm);
 }
 }




 public function addPackage(PackageInterface $package)
 {

 if (isset($this->overrides[strtolower($package->getName())])) {
 return;
 }
 parent::addPackage($package);
 }

 private function buildPackageName($name)
 {
 return 'ext-' . str_replace(' ', '-', $name);
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\PackageInterface;








 interface RepositoryInterface extends \Countable
 {
 const SEARCH_FULLTEXT = 0;
 const SEARCH_NAME = 1;








 public function hasPackage(PackageInterface $package);









 public function findPackage($name, $constraint);









 public function findPackages($name, $constraint = null);






 public function getPackages();








 public function search($query, $mode = 0);
 }
 <?php











 namespace Composer\Repository;

 use Composer\IO\IOInterface;
 use Composer\Config;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\Package\PackageInterface;








 class RepositoryManager
 {
 private $localRepository;
 private $repositories = array();
 private $repositoryClasses = array();
 private $io;
 private $config;
 private $eventDispatcher;

 public function __construct(IOInterface $io, Config $config, EventDispatcher $eventDispatcher = null)
 {
 $this->io = $io;
 $this->config = $config;
 $this->eventDispatcher = $eventDispatcher;
 }









 public function findPackage($name, $constraint)
 {
 foreach ($this->repositories as $repository) {
 if ($package = $repository->findPackage($name, $constraint)) {
 return $package;
 }
 }
 }









 public function findPackages($name, $constraint)
 {
 $packages = array();

 foreach ($this->repositories as $repository) {
 $packages = array_merge($packages, $repository->findPackages($name, $constraint));
 }

 return $packages;
 }






 public function addRepository(RepositoryInterface $repository)
 {
 $this->repositories[] = $repository;
 }









 public function createRepository($type, $config)
 {
 if (!isset($this->repositoryClasses[$type])) {
 throw new \InvalidArgumentException('Repository type is not registered: '.$type);
 }

 $class = $this->repositoryClasses[$type];

 return new $class($config, $this->io, $this->config, $this->eventDispatcher);
 }







 public function setRepositoryClass($type, $class)
 {
 $this->repositoryClasses[$type] = $class;
 }






 public function getRepositories()
 {
 return $this->repositories;
 }






 public function setLocalRepository(WritableRepositoryInterface $repository)
 {
 $this->localRepository = $repository;
 }






 public function getLocalRepository()
 {
 return $this->localRepository;
 }







 public function getLocalRepositories()
 {
 trigger_error('This method is deprecated, use getLocalRepository instead since the getLocalDevRepository is now gone', E_USER_DEPRECATED);

 return array($this->localRepository);
 }
 }
 <?php











 namespace Composer\Repository;






 class RepositorySecurityException extends \Exception
 {
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\Json\JsonFile;
 use Composer\IO\IOInterface;




 class GitBitbucketDriver extends VcsDriver implements VcsDriverInterface
 {
 protected $owner;
 protected $repository;
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $infoCache = array();




 public function initialize()
 {
 preg_match('#^https?://bitbucket\.org/([^/]+)/(.+?)\.git$#', $this->url, $match);
 $this->owner = $match[1];
 $this->repository = $match[2];
 $this->originUrl = 'bitbucket.org';
 }




 public function getRootIdentifier()
 {
 if (null === $this->rootIdentifier) {
 $resource = $this->getScheme() . '://api.bitbucket.org/1.0/repositories/'.$this->owner.'/'.$this->repository;
 $repoData = JsonFile::parseJson($this->getContents($resource), $resource);
 $this->rootIdentifier = !empty($repoData['main_branch']) ? $repoData['main_branch'] : 'master';
 }

 return $this->rootIdentifier;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function getSource($identifier)
 {
 return array('type' => 'git', 'url' => $this->getUrl(), 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 $url = $this->getScheme() . '://bitbucket.org/'.$this->owner.'/'.$this->repository.'/get/'.$identifier.'.zip';

 return array('type' => 'zip', 'url' => $url, 'reference' => $identifier, 'shasum' => '');
 }




 public function getComposerInformation($identifier)
 {
 if (!isset($this->infoCache[$identifier])) {
 $resource = $this->getScheme() . '://bitbucket.org/'.$this->owner.'/'.$this->repository.'/raw/'.$identifier.'/composer.json';
 $composer = $this->getContents($resource);
 if (!$composer) {
 return;
 }

 $composer = JsonFile::parseJson($composer, $resource);

 if (empty($composer['time'])) {
 $resource = $this->getScheme() . '://api.bitbucket.org/1.0/repositories/'.$this->owner.'/'.$this->repository.'/changesets/'.$identifier;
 $changeset = JsonFile::parseJson($this->getContents($resource), $resource);
 $composer['time'] = $changeset['timestamp'];
 }
 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if (null === $this->tags) {
 $resource = $this->getScheme() . '://api.bitbucket.org/1.0/repositories/'.$this->owner.'/'.$this->repository.'/tags';
 $tagsData = JsonFile::parseJson($this->getContents($resource), $resource);
 $this->tags = array();
 foreach ($tagsData as $tag => $data) {
 $this->tags[$tag] = $data['raw_node'];
 }
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if (null === $this->branches) {
 $resource = $this->getScheme() . '://api.bitbucket.org/1.0/repositories/'.$this->owner.'/'.$this->repository.'/branches';
 $branchData = JsonFile::parseJson($this->getContents($resource), $resource);
 $this->branches = array();
 foreach ($branchData as $branch => $data) {
 $this->branches[$branch] = $data['raw_node'];
 }
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if (!preg_match('#^https?://bitbucket\.org/([^/]+)/(.+?)\.git$#', $url)) {
 return false;
 }

 if (!extension_loaded('openssl')) {
 if ($io->isVerbose()) {
 $io->writeError('Skipping Bitbucket git driver for '.$url.' because the OpenSSL PHP extension is missing.');
 }

 return false;
 }

 return true;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Json\JsonFile;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\Filesystem;
 use Composer\Util\Git as GitUtil;
 use Composer\IO\IOInterface;
 use Composer\Cache;
 use Composer\Config;




 class GitDriver extends VcsDriver
 {
 protected $cache;
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $repoDir;
 protected $infoCache = array();




 public function initialize()
 {
 if (Filesystem::isLocalPath($this->url)) {
 $this->repoDir = $this->url;
 $cacheUrl = realpath($this->url);
 } else {
 $this->repoDir = $this->config->get('cache-vcs-dir') . '/' . preg_replace('{[^a-z0-9.]}i', '-', $this->url) . '/';

 GitUtil::cleanEnv();

 $fs = new Filesystem();
 $fs->ensureDirectoryExists(dirname($this->repoDir));

 if (!is_writable(dirname($this->repoDir))) {
 throw new \RuntimeException('Can not clone '.$this->url.' to access package information. The "'.dirname($this->repoDir).'" directory is not writable by the current user.');
 }

 if (preg_match('{^ssh://[^@]+@[^:]+:[^0-9]+}', $this->url)) {
 throw new \InvalidArgumentException('The source URL '.$this->url.' is invalid, ssh URLs should have a port number after ":".'."\n".'Use ssh://[email protected]:22/path or just [email protected]:path if you do not want to provide a password or custom port.');
 }

 $gitUtil = new GitUtil($this->io, $this->config, $this->process, $fs);


 if (is_dir($this->repoDir) && 0 === $this->process->execute('git rev-parse --git-dir', $output, $this->repoDir) && trim($output) === '.') {
 try {
 $commandCallable = function ($url) {
 return sprintf('git remote set-url origin %s && git remote update --prune origin', ProcessExecutor::escape($url));
 };
 $gitUtil->runCommand($commandCallable, $this->url, $this->repoDir);
 } catch (\Exception $e) {
 $this->io->writeError('<error>Failed to update '.$this->url.', package information from this repository may be outdated ('.$e->getMessage().')</error>');
 }
 } else {

 $fs->removeDirectory($this->repoDir);

 $repoDir = $this->repoDir;
 $commandCallable = function ($url) use ($repoDir) {
 return sprintf('git clone --mirror %s %s', ProcessExecutor::escape($url), ProcessExecutor::escape($repoDir));
 };

 $gitUtil->runCommand($commandCallable, $this->url, $this->repoDir, true);
 }

 $cacheUrl = $this->url;
 }

 $this->getTags();
 $this->getBranches();

 $this->cache = new Cache($this->io, $this->config->get('cache-repo-dir').'/'.preg_replace('{[^a-z0-9.]}i', '-', $cacheUrl));
 }




 public function getRootIdentifier()
 {
 if (null === $this->rootIdentifier) {
 $this->rootIdentifier = 'master';


 $this->process->execute('git branch --no-color', $output, $this->repoDir);
 $branches = $this->process->splitLines($output);
 if (!in_array('* master', $branches)) {
 foreach ($branches as $branch) {
 if ($branch && preg_match('{^\* +(\S+)}', $branch, $match)) {
 $this->rootIdentifier = $match[1];
 break;
 }
 }
 }
 }

 return $this->rootIdentifier;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function getSource($identifier)
 {
 return array('type' => 'git', 'url' => $this->getUrl(), 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 return null;
 }




 public function getComposerInformation($identifier)
 {
 if (preg_match('{[a-f0-9]{40}}i', $identifier) && $res = $this->cache->read($identifier)) {
 $this->infoCache[$identifier] = JsonFile::parseJson($res);
 }

 if (!isset($this->infoCache[$identifier])) {
 $resource = sprintf('%s:composer.json', ProcessExecutor::escape($identifier));
 $this->process->execute(sprintf('git show %s', $resource), $composer, $this->repoDir);

 if (!trim($composer)) {
 return;
 }

 $composer = JsonFile::parseJson($composer, $resource);

 if (empty($composer['time'])) {
 $this->process->execute(sprintf('git log -1 --format=%%at %s', ProcessExecutor::escape($identifier)), $output, $this->repoDir);
 $date = new \DateTime('@'.trim($output), new \DateTimeZone('UTC'));
 $composer['time'] = $date->format('Y-m-d H:i:s');
 }

 if (preg_match('{[a-f0-9]{40}}i', $identifier)) {
 $this->cache->write($identifier, json_encode($composer));
 }

 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if (null === $this->tags) {
 $this->tags = array();

 $this->process->execute('git show-ref --tags', $output, $this->repoDir);
 foreach ($output = $this->process->splitLines($output) as $tag) {
 if ($tag && preg_match('{^([a-f0-9]{40}) refs/tags/(\S+)$}', $tag, $match)) {
 $this->tags[$match[2]] = $match[1];
 }
 }
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if (null === $this->branches) {
 $branches = array();

 $this->process->execute('git branch --no-color --no-abbrev -v', $output, $this->repoDir);
 foreach ($this->process->splitLines($output) as $branch) {
 if ($branch && !preg_match('{^ *[^/]+/HEAD }', $branch)) {
 if (preg_match('{^(?:\* )? *(\S+) *([a-f0-9]+)(?: .*)?$}', $branch, $match)) {
 $branches[$match[1]] = $match[2];
 }
 }
 }

 $this->branches = $branches;
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if (preg_match('#(^git://|\.git$|git(?:olite)?@|//git\.|//github.com/)#i', $url)) {
 return true;
 }


 if (Filesystem::isLocalPath($url)) {
 $url = Filesystem::getPlatformPath($url);
 if (!is_dir($url)) {
 return false;
 }

 $process = new ProcessExecutor($io);

 if ($process->execute('git tag', $output, $url) === 0) {
 return true;
 }
 }

 if (!$deep) {
 return false;
 }

 $process = new ProcessExecutor($io);
 if ($process->execute('git ls-remote --heads ' . ProcessExecutor::escape($url), $output) === 0) {
 return true;
 }

 return false;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\Downloader\TransportException;
 use Composer\Json\JsonFile;
 use Composer\Cache;
 use Composer\IO\IOInterface;
 use Composer\Util\GitHub;




 class GitHubDriver extends VcsDriver
 {
 protected $cache;
 protected $owner;
 protected $repository;
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $hasIssues;
 protected $infoCache = array();
 protected $isPrivate = false;






 protected $gitDriver;




 public function initialize()
 {
 preg_match('#^(?:(?:https?|git)://([^/]+)/|git@([^:]+):)([^/]+)/(.+?)(?:\.git|/)?$#', $this->url, $match);
 $this->owner = $match[3];
 $this->repository = $match[4];
 $this->originUrl = !empty($match[1]) ? $match[1] : $match[2];
 if ($this->originUrl === 'www.github.com') {
 $this->originUrl = 'github.com';
 }
 $this->cache = new Cache($this->io, $this->config->get('cache-repo-dir').'/'.$this->originUrl.'/'.$this->owner.'/'.$this->repository);

 if (isset($this->repoConfig['no-api']) && $this->repoConfig['no-api']) {
 $this->setupGitDriver($this->url);

 return;
 }

 $this->fetchRootIdentifier();
 }

 public function getRepositoryUrl()
 {
 return 'https://'.$this->originUrl.'/'.$this->owner.'/'.$this->repository;
 }




 public function getRootIdentifier()
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getRootIdentifier();
 }

 return $this->rootIdentifier;
 }




 public function getUrl()
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getUrl();
 }

 return 'https://' . $this->originUrl . '/'.$this->owner.'/'.$this->repository.'.git';
 }




 protected function getApiUrl()
 {
 if ('github.com' === $this->originUrl) {
 $apiUrl = 'api.github.com';
 } else {
 $apiUrl = $this->originUrl . '/api/v3';
 }

 return 'https://' . $apiUrl;
 }




 public function getSource($identifier)
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getSource($identifier);
 }
 if ($this->isPrivate) {

 
 $url = $this->generateSshUrl();
 } else {
 $url = $this->getUrl();
 }

 return array('type' => 'git', 'url' => $url, 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 $url = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository.'/zipball/'.$identifier;

 return array('type' => 'zip', 'url' => $url, 'reference' => $identifier, 'shasum' => '');
 }




 public function getComposerInformation($identifier)
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getComposerInformation($identifier);
 }

 if (preg_match('{[a-f0-9]{40}}i', $identifier) && $res = $this->cache->read($identifier)) {
 $this->infoCache[$identifier] = JsonFile::parseJson($res);
 }

 if (!isset($this->infoCache[$identifier])) {
 $notFoundRetries = 2;
 while ($notFoundRetries) {
 try {
 $resource = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository.'/contents/composer.json?ref='.urlencode($identifier);
 $composer = JsonFile::parseJson($this->getContents($resource));
 if (empty($composer['content']) || $composer['encoding'] !== 'base64' || !($composer = base64_decode($composer['content']))) {
 throw new \RuntimeException('Could not retrieve composer.json from '.$resource);
 }
 break;
 } catch (TransportException $e) {
 if (404 !== $e->getCode()) {
 throw $e;
 }


 
 $notFoundRetries--;
 $composer = false;
 }
 }

 if ($composer) {
 $composer = JsonFile::parseJson($composer, $resource);

 if (empty($composer['time'])) {
 $resource = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository.'/commits/'.urlencode($identifier);
 $commit = JsonFile::parseJson($this->getContents($resource), $resource);
 $composer['time'] = $commit['commit']['committer']['date'];
 }
 if (!isset($composer['support']['source'])) {
 $label = array_search($identifier, $this->getTags()) ?: array_search($identifier, $this->getBranches()) ?: $identifier;
 $composer['support']['source'] = sprintf('https://%s/%s/%s/tree/%s', $this->originUrl, $this->owner, $this->repository, $label);
 }
 if (!isset($composer['support']['issues']) && $this->hasIssues) {
 $composer['support']['issues'] = sprintf('https://%s/%s/%s/issues', $this->originUrl, $this->owner, $this->repository);
 }
 }

 if (preg_match('{[a-f0-9]{40}}i', $identifier)) {
 $this->cache->write($identifier, json_encode($composer));
 }

 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getTags();
 }
 if (null === $this->tags) {
 $this->tags = array();
 $resource = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository.'/tags?per_page=100';

 do {
 $tagsData = JsonFile::parseJson($this->getContents($resource), $resource);
 foreach ($tagsData as $tag) {
 $this->tags[$tag['name']] = $tag['commit']['sha'];
 }

 $resource = $this->getNextPage();
 } while ($resource);
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if ($this->gitDriver) {
 return $this->gitDriver->getBranches();
 }
 if (null === $this->branches) {
 $this->branches = array();
 $resource = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository.'/git/refs/heads?per_page=100';

 $branchBlacklist = array('gh-pages');

 do {
 $branchData = JsonFile::parseJson($this->getContents($resource), $resource);
 foreach ($branchData as $branch) {
 $name = substr($branch['ref'], 11);
 if (!in_array($name, $branchBlacklist)) {
 $this->branches[$name] = $branch['object']['sha'];
 }
 }

 $resource = $this->getNextPage();
 } while ($resource);
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if (!preg_match('#^((?:https?|git)://([^/]+)/|git@([^:]+):)([^/]+)/(.+?)(?:\.git|/)?$#', $url, $matches)) {
 return false;
 }

 $originUrl = !empty($matches[2]) ? $matches[2] : $matches[3];
 if (!in_array(preg_replace('{^www\.}i', '', $originUrl), $config->get('github-domains'))) {
 return false;
 }

 if (!extension_loaded('openssl')) {
 if ($io->isVerbose()) {
 $io->writeError('Skipping GitHub driver for '.$url.' because the OpenSSL PHP extension is missing.');
 }

 return false;
 }

 return true;
 }






 protected function generateSshUrl()
 {
 return 'git@' . $this->originUrl . ':'.$this->owner.'/'.$this->repository.'.git';
 }




 protected function getContents($url, $fetchingRepoData = false)
 {
 try {
 return parent::getContents($url);
 } catch (TransportException $e) {
 $gitHubUtil = new GitHub($this->io, $this->config, $this->process, $this->remoteFilesystem);

 switch ($e->getCode()) {
 case 401:
 case 404:

 if (!$fetchingRepoData) {
 throw $e;
 }

 if ($gitHubUtil->authorizeOAuth($this->originUrl)) {
 return parent::getContents($url);
 }

 if (!$this->io->isInteractive()) {
 return $this->attemptCloneFallback();
 }

 $gitHubUtil->authorizeOAuthInteractively($this->originUrl, 'Your GitHub credentials are required to fetch private repository metadata (<info>'.$this->url.'</info>)');

 return parent::getContents($url);

 case 403:
 if (!$this->io->hasAuthentication($this->originUrl) && $gitHubUtil->authorizeOAuth($this->originUrl)) {
 return parent::getContents($url);
 }

 if (!$this->io->isInteractive() && $fetchingRepoData) {
 return $this->attemptCloneFallback();
 }

 $rateLimited = false;
 foreach ($e->getHeaders() as $header) {
 if (preg_match('{^X-RateLimit-Remaining: *0$}i', trim($header))) {
 $rateLimited = true;
 }
 }

 if (!$this->io->hasAuthentication($this->originUrl)) {
 if (!$this->io->isInteractive()) {
 $this->io->writeError('<error>GitHub API limit exhausted. Failed to get metadata for the '.$this->url.' repository, try running in interactive mode so that you can enter your GitHub credentials to increase the API limit</error>');
 throw $e;
 }

 $gitHubUtil->authorizeOAuthInteractively($this->originUrl, 'API limit exhausted. Enter your GitHub credentials to get a larger API limit (<info>'.$this->url.'</info>)');

 return parent::getContents($url);
 }

 if ($rateLimited) {
 $rateLimit = $this->getRateLimit($e->getHeaders());
 $this->io->writeError(sprintf(
 '<error>GitHub API limit (%d calls/hr) is exhausted. You are already authorized so you have to wait until %s before doing more requests</error>',
 $rateLimit['limit'],
 $rateLimit['reset']
 ));
 }

 throw $e;

 default:
 throw $e;
 }
 }
 }








 protected function getRateLimit(array $headers)
 {
 $rateLimit = array(
 'limit' => '?',
 'reset' => '?',
 );

 foreach ($headers as $header) {
 $header = trim($header);
 if (false === strpos($header, 'X-RateLimit-')) {
 continue;
 }
 list($type, $value) = explode(':', $header, 2);
 switch ($type) {
 case 'X-RateLimit-Limit':
 $rateLimit['limit'] = (int) trim($value);
 break;
 case 'X-RateLimit-Reset':
 $rateLimit['reset'] = date('Y-m-d H:i:s', (int) trim($value));
 break;
 }
 }

 return $rateLimit;
 }






 protected function fetchRootIdentifier()
 {
 $repoDataUrl = $this->getApiUrl() . '/repos/'.$this->owner.'/'.$this->repository;

 $repoData = JsonFile::parseJson($this->getContents($repoDataUrl, true), $repoDataUrl);
 if (null === $repoData && null !== $this->gitDriver) {
 return;
 }

 $this->owner = $repoData['owner']['login'];
 $this->repository = $repoData['name'];

 $this->isPrivate = !empty($repoData['private']);
 if (isset($repoData['default_branch'])) {
 $this->rootIdentifier = $repoData['default_branch'];
 } elseif (isset($repoData['master_branch'])) {
 $this->rootIdentifier = $repoData['master_branch'];
 } else {
 $this->rootIdentifier = 'master';
 }
 $this->hasIssues = !empty($repoData['has_issues']);
 }

 protected function attemptCloneFallback()
 {
 $this->isPrivate = true;

 try {

 
 
 
 $this->setupGitDriver($this->generateSshUrl());

 return;
 } catch (\RuntimeException $e) {
 $this->gitDriver = null;

 $this->io->writeError('<error>Failed to clone the '.$this->generateSshUrl().' repository, try running in interactive mode so that you can enter your GitHub credentials</error>');
 throw $e;
 }
 }

 protected function setupGitDriver($url)
 {
 $this->gitDriver = new GitDriver(
 array('url' => $url),
 $this->io,
 $this->config,
 $this->process,
 $this->remoteFilesystem
 );
 $this->gitDriver->initialize();
 }

 protected function getNextPage()
 {
 $headers = $this->remoteFilesystem->getLastHeaders();
 foreach ($headers as $header) {
 if (substr($header, 0, 5) === 'Link:') {
 $links = explode(',', substr($header, 5));
 foreach ($links as $link) {
 if (preg_match('{<(.+?)>; *rel="next"}', $link, $match)) {
 return $match[1];
 }
 }
 }
 }
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\Json\JsonFile;
 use Composer\IO\IOInterface;




 class HgBitbucketDriver extends VcsDriver
 {
 protected $owner;
 protected $repository;
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $infoCache = array();




 public function initialize()
 {
 preg_match('#^https?://bitbucket\.org/([^/]+)/([^/]+)/?$#', $this->url, $match);
 $this->owner = $match[1];
 $this->repository = $match[2];
 $this->originUrl = 'bitbucket.org';
 }




 public function getRootIdentifier()
 {
 if (null === $this->rootIdentifier) {
 $resource = $this->getScheme() . '://bitbucket.org/api/1.0/repositories/'.$this->owner.'/'.$this->repository.'/tags';
 $repoData = JsonFile::parseJson($this->getContents($resource), $resource);
 if (array() === $repoData || !isset($repoData['tip'])) {
 throw new \RuntimeException($this->url.' does not appear to be a mercurial repository, use '.$this->url.'.git if this is a git bitbucket repository');
 }
 $this->rootIdentifier = $repoData['tip']['raw_node'];
 }

 return $this->rootIdentifier;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function getSource($identifier)
 {
 return array('type' => 'hg', 'url' => $this->getUrl(), 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 $url = $this->getScheme() . '://bitbucket.org/'.$this->owner.'/'.$this->repository.'/get/'.$identifier.'.zip';

 return array('type' => 'zip', 'url' => $url, 'reference' => $identifier, 'shasum' => '');
 }




 public function getComposerInformation($identifier)
 {
 if (!isset($this->infoCache[$identifier])) {
 $resource = $this->getScheme() . '://bitbucket.org/api/1.0/repositories/'.$this->owner.'/'.$this->repository.'/src/'.$identifier.'/composer.json';
 $repoData = JsonFile::parseJson($this->getContents($resource), $resource);


 
 
 

 if (!array_key_exists('data', $repoData)) {
 return;
 }

 $composer = JsonFile::parseJson($repoData['data'], $resource);

 if (empty($composer['time'])) {
 $resource = $this->getScheme() . '://bitbucket.org/api/1.0/repositories/'.$this->owner.'/'.$this->repository.'/changesets/'.$identifier;
 $changeset = JsonFile::parseJson($this->getContents($resource), $resource);
 $composer['time'] = $changeset['timestamp'];
 }
 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if (null === $this->tags) {
 $resource = $this->getScheme() . '://bitbucket.org/api/1.0/repositories/'.$this->owner.'/'.$this->repository.'/tags';
 $tagsData = JsonFile::parseJson($this->getContents($resource), $resource);
 $this->tags = array();
 foreach ($tagsData as $tag => $data) {
 $this->tags[$tag] = $data['raw_node'];
 }
 unset($this->tags['tip']);
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if (null === $this->branches) {
 $resource = $this->getScheme() . '://bitbucket.org/api/1.0/repositories/'.$this->owner.'/'.$this->repository.'/branches';
 $branchData = JsonFile::parseJson($this->getContents($resource), $resource);
 $this->branches = array();
 foreach ($branchData as $branch => $data) {
 $this->branches[$branch] = $data['raw_node'];
 }
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if (!preg_match('#^https?://bitbucket\.org/([^/]+)/([^/]+)/?$#', $url)) {
 return false;
 }

 if (!extension_loaded('openssl')) {
 if ($io->isVerbose()) {
 $io->writeError('Skipping Bitbucket hg driver for '.$url.' because the OpenSSL PHP extension is missing.');
 }

 return false;
 }

 return true;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\Json\JsonFile;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\Filesystem;
 use Composer\IO\IOInterface;




 class HgDriver extends VcsDriver
 {
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $repoDir;
 protected $infoCache = array();




 public function initialize()
 {
 if (Filesystem::isLocalPath($this->url)) {
 $this->repoDir = $this->url;
 } else {
 $cacheDir = $this->config->get('cache-vcs-dir');
 $this->repoDir = $cacheDir . '/' . preg_replace('{[^a-z0-9]}i', '-', $this->url) . '/';

 $fs = new Filesystem();
 $fs->ensureDirectoryExists($cacheDir);

 if (!is_writable(dirname($this->repoDir))) {
 throw new \RuntimeException('Can not clone '.$this->url.' to access package information. The "'.$cacheDir.'" directory is not writable by the current user.');
 }


 if (is_dir($this->repoDir) && 0 === $this->process->execute('hg summary', $output, $this->repoDir)) {
 if (0 !== $this->process->execute('hg pull', $output, $this->repoDir)) {
 $this->io->writeError('<error>Failed to update '.$this->url.', package information from this repository may be outdated ('.$this->process->getErrorOutput().')</error>');
 }
 } else {

 $fs->removeDirectory($this->repoDir);

 if (0 !== $this->process->execute(sprintf('hg clone --noupdate %s %s', ProcessExecutor::escape($this->url), ProcessExecutor::escape($this->repoDir)), $output, $cacheDir)) {
 $output = $this->process->getErrorOutput();

 if (0 !== $this->process->execute('hg --version', $ignoredOutput)) {
 throw new \RuntimeException('Failed to clone '.$this->url.', hg was not found, check that it is installed and in your PATH env.' . "\n\n" . $this->process->getErrorOutput());
 }

 throw new \RuntimeException('Failed to clone '.$this->url.', could not read packages from it' . "\n\n" .$output);
 }
 }
 }

 $this->getTags();
 $this->getBranches();
 }




 public function getRootIdentifier()
 {
 if (null === $this->rootIdentifier) {
 $this->process->execute(sprintf('hg tip --template "{node}"'), $output, $this->repoDir);
 $output = $this->process->splitLines($output);
 $this->rootIdentifier = $output[0];
 }

 return $this->rootIdentifier;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function getSource($identifier)
 {
 return array('type' => 'hg', 'url' => $this->getUrl(), 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 return null;
 }




 public function getComposerInformation($identifier)
 {
 if (!isset($this->infoCache[$identifier])) {
 $this->process->execute(sprintf('hg cat -r %s composer.json', ProcessExecutor::escape($identifier)), $composer, $this->repoDir);

 if (!trim($composer)) {
 return;
 }

 $composer = JsonFile::parseJson($composer, $identifier);

 if (empty($composer['time'])) {
 $this->process->execute(sprintf('hg log --template "{date|rfc3339date}" -r %s', ProcessExecutor::escape($identifier)), $output, $this->repoDir);
 $date = new \DateTime(trim($output), new \DateTimeZone('UTC'));
 $composer['time'] = $date->format('Y-m-d H:i:s');
 }
 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if (null === $this->tags) {
 $tags = array();

 $this->process->execute('hg tags', $output, $this->repoDir);
 foreach ($this->process->splitLines($output) as $tag) {
 if ($tag && preg_match('(^([^\s]+)\s+\d+:(.*)$)', $tag, $match)) {
 $tags[$match[1]] = $match[2];
 }
 }
 unset($tags['tip']);

 $this->tags = $tags;
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if (null === $this->branches) {
 $branches = array();
 $bookmarks = array();

 $this->process->execute('hg branches', $output, $this->repoDir);
 foreach ($this->process->splitLines($output) as $branch) {
 if ($branch && preg_match('(^([^\s]+)\s+\d+:([a-f0-9]+))', $branch, $match)) {
 $branches[$match[1]] = $match[2];
 }
 }

 $this->process->execute('hg bookmarks', $output, $this->repoDir);
 foreach ($this->process->splitLines($output) as $branch) {
 if ($branch && preg_match('(^(?:[\s*]*)([^\s]+)\s+\d+:(.*)$)', $branch, $match)) {
 $bookmarks[$match[1]] = $match[2];
 }
 }


 $this->branches = array_merge($bookmarks, $branches);
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if (preg_match('#(^(?:https?|ssh)://(?:[^@]@)?bitbucket.org|https://(?:.*?)\.kilnhg.com)#i', $url)) {
 return true;
 }


 if (Filesystem::isLocalPath($url)) {
 $url = Filesystem::getPlatformPath($url);
 if (!is_dir($url)) {
 return false;
 }

 $process = new ProcessExecutor();

 if ($process->execute('hg summary', $output, $url) === 0) {
 return true;
 }
 }

 if (!$deep) {
 return false;
 }

 $processExecutor = new ProcessExecutor();
 $exit = $processExecutor->execute(sprintf('hg identify %s', ProcessExecutor::escape($url)), $ignored);

 return $exit === 0;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\IO\IOInterface;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\Perforce;




 class PerforceDriver extends VcsDriver
 {
 protected $depot;
 protected $branch;
 protected $perforce;
 protected $composerInfo;
 protected $composerInfoIdentifier;




 public function initialize()
 {
 $this->depot = $this->repoConfig['depot'];
 $this->branch = '';
 if (!empty($this->repoConfig['branch'])) {
 $this->branch = $this->repoConfig['branch'];
 }

 $this->initPerforce($this->repoConfig);
 $this->perforce->p4Login($this->io);
 $this->perforce->checkStream($this->depot);

 $this->perforce->writeP4ClientSpec();
 $this->perforce->connectClient();

 return true;
 }

 private function initPerforce($repoConfig)
 {
 if (!empty($this->perforce)) {
 return;
 }

 $repoDir = $this->config->get('cache-vcs-dir') . '/' . $this->depot;
 $this->perforce = Perforce::create($repoConfig, $this->getUrl(), $repoDir, $this->process, $this->io);
 }




 public function getComposerInformation($identifier)
 {
 if (!empty($this->composerInfoIdentifier)) {
 if (strcmp($identifier, $this->composerInfoIdentifier) === 0) {
 return $this->composerInfo;
 }
 }
 $composer_info = $this->perforce->getComposerInformation($identifier);

 return $composer_info;
 }




 public function getRootIdentifier()
 {
 return $this->branch;
 }




 public function getBranches()
 {
 $branches = $this->perforce->getBranches();

 return $branches;
 }




 public function getTags()
 {
 $tags = $this->perforce->getTags();

 return $tags;
 }




 public function getDist($identifier)
 {
 return null;
 }




 public function getSource($identifier)
 {
 $source = array(
 'type' => 'perforce',
 'url' => $this->repoConfig['url'],
 'reference' => $identifier,
 'p4user' => $this->perforce->getUser()
 );

 return $source;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function hasComposerFile($identifier)
 {
 $this->composerInfo = $this->perforce->getComposerInformation('//' . $this->depot . '/' . $identifier);
 $this->composerInfoIdentifier = $identifier;

 return !empty($this->composerInfo);
 }




 public function getContents($url)
 {
 return false;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 if ($deep || preg_match('#\b(perforce|p4)\b#i', $url)) {
 return Perforce::checkServerExists($url, new ProcessExecutor($io));
 }

 return false;
 }




 public function cleanup()
 {
 $this->perforce->cleanupClientSpec();
 $this->perforce = null;
 }

 public function getDepot()
 {
 return $this->depot;
 }

 public function getBranch()
 {
 return $this->branch;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Cache;
 use Composer\Config;
 use Composer\Json\JsonFile;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\Filesystem;
 use Composer\Util\Svn as SvnUtil;
 use Composer\IO\IOInterface;
 use Composer\Downloader\TransportException;





 class SvnDriver extends VcsDriver
 {



 protected $cache;
 protected $baseUrl;
 protected $tags;
 protected $branches;
 protected $rootIdentifier;
 protected $infoCache = array();

 protected $trunkPath = 'trunk';
 protected $branchesPath = 'branches';
 protected $tagsPath = 'tags';
 protected $packagePath = '';
 protected $cacheCredentials = true;




 private $util;




 public function initialize()
 {
 $this->url = $this->baseUrl = rtrim(self::normalizeUrl($this->url), '/');

 SvnUtil::cleanEnv();

 if (isset($this->repoConfig['trunk-path'])) {
 $this->trunkPath = $this->repoConfig['trunk-path'];
 }
 if (isset($this->repoConfig['branches-path'])) {
 $this->branchesPath = $this->repoConfig['branches-path'];
 }
 if (isset($this->repoConfig['tags-path'])) {
 $this->tagsPath = $this->repoConfig['tags-path'];
 }
 if (array_key_exists('svn-cache-credentials', $this->repoConfig)) {
 $this->cacheCredentials = (bool) $this->repoConfig['svn-cache-credentials'];
 }
 if (isset($this->repoConfig['package-path'])) {
 $this->packagePath = '/' . trim($this->repoConfig['package-path'], '/');
 }

 if (false !== ($pos = strrpos($this->url, '/' . $this->trunkPath))) {
 $this->baseUrl = substr($this->url, 0, $pos);
 }

 $this->cache = new Cache($this->io, $this->config->get('cache-repo-dir').'/'.preg_replace('{[^a-z0-9.]}i', '-', $this->baseUrl));

 $this->getBranches();
 $this->getTags();
 }




 public function getRootIdentifier()
 {
 return $this->rootIdentifier ?: $this->trunkPath;
 }




 public function getUrl()
 {
 return $this->url;
 }




 public function getSource($identifier)
 {
 return array('type' => 'svn', 'url' => $this->baseUrl, 'reference' => $identifier);
 }




 public function getDist($identifier)
 {
 return null;
 }




 public function getComposerInformation($identifier)
 {
 $identifier = '/' . trim($identifier, '/') . '/';

 if ($res = $this->cache->read($identifier.'.json')) {
 $this->infoCache[$identifier] = JsonFile::parseJson($res);
 }

 if (!isset($this->infoCache[$identifier])) {
 preg_match('{^(.+?)(@\d+)?/$}', $identifier, $match);
 if (!empty($match[2])) {
 $path = $match[1];
 $rev = $match[2];
 } else {
 $path = $identifier;
 $rev = '';
 }

 try {
 $resource = $path.'composer.json';
 $output = $this->execute('svn cat', $this->baseUrl . $resource . $rev);
 if (!trim($output)) {
 return;
 }
 } catch (\RuntimeException $e) {
 throw new TransportException($e->getMessage());
 }

 $composer = JsonFile::parseJson($output, $this->baseUrl . $resource . $rev);

 if (empty($composer['time'])) {
 $output = $this->execute('svn info', $this->baseUrl . $path . $rev);
 foreach ($this->process->splitLines($output) as $line) {
 if ($line && preg_match('{^Last Changed Date: ([^(]+)}', $line, $match)) {
 $date = new \DateTime($match[1], new \DateTimeZone('UTC'));
 $composer['time'] = $date->format('Y-m-d H:i:s');
 break;
 }
 }
 }

 $this->cache->write($identifier.'.json', json_encode($composer));
 $this->infoCache[$identifier] = $composer;
 }

 return $this->infoCache[$identifier];
 }




 public function getTags()
 {
 if (null === $this->tags) {
 $this->tags = array();

 if ($this->tagsPath !== false) {
 $output = $this->execute('svn ls --verbose', $this->baseUrl . '/' . $this->tagsPath);
 if ($output) {
 foreach ($this->process->splitLines($output) as $line) {
 $line = trim($line);
 if ($line && preg_match('{^\s*(\S+).*?(\S+)\s*$}', $line, $match)) {
 if (isset($match[1]) && isset($match[2]) && $match[2] !== './') {
 $this->tags[rtrim($match[2], '/')] = $this->buildIdentifier(
 '/' . $this->tagsPath . '/' . $match[2],
 $match[1]
 );
 }
 }
 }
 }
 }
 }

 return $this->tags;
 }




 public function getBranches()
 {
 if (null === $this->branches) {
 $this->branches = array();

 if (false === $this->trunkPath) {
 $trunkParent = $this->baseUrl . '/';
 } else {
 $trunkParent = $this->baseUrl . '/' . $this->trunkPath;
 }

 $output = $this->execute('svn ls --verbose', $trunkParent);
 if ($output) {
 foreach ($this->process->splitLines($output) as $line) {
 $line = trim($line);
 if ($line && preg_match('{^\s*(\S+).*?(\S+)\s*$}', $line, $match)) {
 if (isset($match[1]) && isset($match[2]) && $match[2] === './') {
 $this->branches['trunk'] = $this->buildIdentifier(
 '/' . $this->trunkPath,
 $match[1]
 );
 $this->rootIdentifier = $this->branches['trunk'];
 break;
 }
 }
 }
 }
 unset($output);

 if ($this->branchesPath !== false) {
 $output = $this->execute('svn ls --verbose', $this->baseUrl . '/' . $this->branchesPath);
 if ($output) {
 foreach ($this->process->splitLines(trim($output)) as $line) {
 $line = trim($line);
 if ($line && preg_match('{^\s*(\S+).*?(\S+)\s*$}', $line, $match)) {
 if (isset($match[1]) && isset($match[2]) && $match[2] !== './') {
 $this->branches[rtrim($match[2], '/')] = $this->buildIdentifier(
 '/' . $this->branchesPath . '/' . $match[2],
 $match[1]
 );
 }
 }
 }
 }
 }
 }

 return $this->branches;
 }




 public static function supports(IOInterface $io, Config $config, $url, $deep = false)
 {
 $url = self::normalizeUrl($url);
 if (preg_match('#(^svn://|^svn\+ssh://|svn\.)#i', $url)) {
 return true;
 }


 if (!$deep && !Filesystem::isLocalPath($url)) {
 return false;
 }

 $processExecutor = new ProcessExecutor();

 $exit = $processExecutor->execute(
 "svn info --non-interactive {$url}",
 $ignoredOutput
 );

 if ($exit === 0) {

 return true;
 }

 if (false !== stripos($processExecutor->getErrorOutput(), 'authorization failed:')) {

 
 return true;
 }

 return false;
 }








 protected static function normalizeUrl($url)
 {
 $fs = new Filesystem();
 if ($fs->isAbsolutePath($url)) {
 return 'file://' . strtr($url, '\\', '/');
 }

 return $url;
 }










 protected function execute($command, $url)
 {
 if (null === $this->util) {
 $this->util = new SvnUtil($this->baseUrl, $this->io, $this->config, $this->process);
 $this->util->setCacheCredentials($this->cacheCredentials);
 }

 try {
 return $this->util->execute($command, $url);
 } catch (\RuntimeException $e) {
 if (0 !== $this->process->execute('svn --version', $ignoredOutput)) {
 throw new \RuntimeException('Failed to load '.$this->url.', svn was not found, check that it is installed and in your PATH env.' . "\n\n" . $this->process->getErrorOutput());
 }

 throw new \RuntimeException(
 'Repository '.$this->url.' could not be processed, '.$e->getMessage()
 );
 }
 }









 protected function buildIdentifier($baseDir, $revision)
 {
 return rtrim($baseDir, '/') . $this->packagePath . '/@' . $revision;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Downloader\TransportException;
 use Composer\Config;
 use Composer\IO\IOInterface;
 use Composer\Util\ProcessExecutor;
 use Composer\Util\RemoteFilesystem;
 use Composer\Util\Filesystem;






 abstract class VcsDriver implements VcsDriverInterface
 {
 protected $url;
 protected $originUrl;
 protected $repoConfig;
 protected $io;
 protected $config;
 protected $process;
 protected $remoteFilesystem;










 final public function __construct(array $repoConfig, IOInterface $io, Config $config, ProcessExecutor $process = null, RemoteFilesystem $remoteFilesystem = null)
 {
 if (Filesystem::isLocalPath($repoConfig['url'])) {
 $repoConfig['url'] = Filesystem::getPlatformPath($repoConfig['url']);
 }

 $this->url = $repoConfig['url'];
 $this->originUrl = $repoConfig['url'];
 $this->repoConfig = $repoConfig;
 $this->io = $io;
 $this->config = $config;
 $this->process = $process ?: new ProcessExecutor($io);
 $this->remoteFilesystem = $remoteFilesystem ?: new RemoteFilesystem($io, $config);
 }




 public function hasComposerFile($identifier)
 {
 try {
 return (bool) $this->getComposerInformation($identifier);
 } catch (TransportException $e) {
 }

 return false;
 }








 protected function getScheme()
 {
 if (extension_loaded('openssl')) {
 return 'https';
 }

 return 'http';
 }








 protected function getContents($url)
 {
 return $this->remoteFilesystem->getContents($this->originUrl, $url, false);
 }




 public function cleanup()
 {
 return;
 }
 }
 <?php











 namespace Composer\Repository\Vcs;

 use Composer\Config;
 use Composer\IO\IOInterface;




 interface VcsDriverInterface
 {



 public function initialize();







 public function getComposerInformation($identifier);






 public function getRootIdentifier();






 public function getBranches();






 public function getTags();





 public function getDist($identifier);





 public function getSource($identifier);






 public function getUrl();








 public function hasComposerFile($identifier);





 public function cleanup();










 public static function supports(IOInterface $io, Config $config, $url, $deep = false);
 }
 <?php











 namespace Composer\Repository;

 use Composer\Downloader\TransportException;
 use Composer\Repository\Vcs\VcsDriverInterface;
 use Composer\Package\Version\VersionParser;
 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Loader\ValidatingArrayLoader;
 use Composer\Package\Loader\InvalidPackageException;
 use Composer\Package\Loader\LoaderInterface;
 use Composer\EventDispatcher\EventDispatcher;
 use Composer\IO\IOInterface;
 use Composer\Config;




 class VcsRepository extends ArrayRepository
 {
 protected $url;
 protected $packageName;
 protected $verbose;
 protected $io;
 protected $config;
 protected $versionParser;
 protected $type;
 protected $loader;
 protected $repoConfig;
 protected $branchErrorOccurred = false;

 public function __construct(array $repoConfig, IOInterface $io, Config $config, EventDispatcher $dispatcher = null, array $drivers = null)
 {
 $this->drivers = $drivers ?: array(
 'github' => 'Composer\Repository\Vcs\GitHubDriver',
 'git-bitbucket' => 'Composer\Repository\Vcs\GitBitbucketDriver',
 'git' => 'Composer\Repository\Vcs\GitDriver',
 'hg-bitbucket' => 'Composer\Repository\Vcs\HgBitbucketDriver',
 'hg' => 'Composer\Repository\Vcs\HgDriver',
 'perforce' => 'Composer\Repository\Vcs\PerforceDriver',

 'svn' => 'Composer\Repository\Vcs\SvnDriver',
 );

 $this->url = $repoConfig['url'];
 $this->io = $io;
 $this->type = isset($repoConfig['type']) ? $repoConfig['type'] : 'vcs';
 $this->verbose = $io->isVeryVerbose();
 $this->config = $config;
 $this->repoConfig = $repoConfig;
 }

 public function getRepoConfig()
 {
 return $this->repoConfig;
 }

 public function setLoader(LoaderInterface $loader)
 {
 $this->loader = $loader;
 }

 public function getDriver()
 {
 if (isset($this->drivers[$this->type])) {
 $class = $this->drivers[$this->type];
 $driver = new $class($this->repoConfig, $this->io, $this->config);
 $driver->initialize();

 return $driver;
 }

 foreach ($this->drivers as $driver) {
 if ($driver::supports($this->io, $this->config, $this->url)) {
 $driver = new $driver($this->repoConfig, $this->io, $this->config);
 $driver->initialize();

 return $driver;
 }
 }

 foreach ($this->drivers as $driver) {
 if ($driver::supports($this->io, $this->config, $this->url, true)) {
 $driver = new $driver($this->repoConfig, $this->io, $this->config);
 $driver->initialize();

 return $driver;
 }
 }
 }

 public function hadInvalidBranches()
 {
 return $this->branchErrorOccurred;
 }

 protected function initialize()
 {
 parent::initialize();

 $verbose = $this->verbose;

 $driver = $this->getDriver();
 if (!$driver) {
 throw new \InvalidArgumentException('No driver found to handle VCS repository '.$this->url);
 }

 $this->versionParser = new VersionParser;
 if (!$this->loader) {
 $this->loader = new ArrayLoader($this->versionParser);
 }

 try {
 if ($driver->hasComposerFile($driver->getRootIdentifier())) {
 $data = $driver->getComposerInformation($driver->getRootIdentifier());
 $this->packageName = !empty($data['name']) ? $data['name'] : null;
 }
 } catch (\Exception $e) {
 if ($verbose) {
 $this->io->writeError('<error>Skipped parsing '.$driver->getRootIdentifier().', '.$e->getMessage().'</error>');
 }
 }

 foreach ($driver->getTags() as $tag => $identifier) {
 $msg = 'Reading composer.json of <info>' . ($this->packageName ?: $this->url) . '</info> (<comment>' . $tag . '</comment>)';
 if ($verbose) {
 $this->io->writeError($msg);
 } else {
 $this->io->overwriteError($msg, false);
 }


 $tag = str_replace('release-', '', $tag);

 if (!$parsedTag = $this->validateTag($tag)) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped tag '.$tag.', invalid tag name</warning>');
 }
 continue;
 }

 try {
 if (!$data = $driver->getComposerInformation($identifier)) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped tag '.$tag.', no composer file</warning>');
 }
 continue;
 }


 if (isset($data['version'])) {
 $data['version_normalized'] = $this->versionParser->normalize($data['version']);
 } else {

 $data['version'] = $tag;
 $data['version_normalized'] = $parsedTag;
 }


 $data['version'] = preg_replace('{[.-]?dev$}i', '', $data['version']);
 $data['version_normalized'] = preg_replace('{(^dev-|[.-]?dev$)}i', '', $data['version_normalized']);


 if ($data['version_normalized'] !== $parsedTag) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped tag '.$tag.', tag ('.$parsedTag.') does not match version ('.$data['version_normalized'].') in composer.json</warning>');
 }
 continue;
 }

 if ($verbose) {
 $this->io->writeError('Importing tag '.$tag.' ('.$data['version_normalized'].')');
 }

 $this->addPackage($this->loader->load($this->preProcess($driver, $data, $identifier)));
 } catch (\Exception $e) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped tag '.$tag.', '.($e instanceof TransportException ? 'no composer file was found' : $e->getMessage()).'</warning>');
 }
 continue;
 }
 }

 if (!$verbose) {
 $this->io->overwriteError('', false);
 }

 foreach ($driver->getBranches() as $branch => $identifier) {
 $msg = 'Reading composer.json of <info>' . ($this->packageName ?: $this->url) . '</info> (<comment>' . $branch . '</comment>)';
 if ($verbose) {
 $this->io->writeError($msg);
 } else {
 $this->io->overwriteError($msg, false);
 }

 if (!$parsedBranch = $this->validateBranch($branch)) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped branch '.$branch.', invalid name</warning>');
 }
 continue;
 }

 try {
 if (!$data = $driver->getComposerInformation($identifier)) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped branch '.$branch.', no composer file</warning>');
 }
 continue;
 }


 $data['version'] = $branch;
 $data['version_normalized'] = $parsedBranch;


 if ('dev-' === substr($parsedBranch, 0, 4) || '9999999-dev' === $parsedBranch) {
 $data['version'] = 'dev-' . $data['version'];
 } else {
 $data['version'] = preg_replace('{(\.9{7})+}', '.x', $parsedBranch);
 }

 if ($verbose) {
 $this->io->writeError('Importing branch '.$branch.' ('.$data['version'].')');
 }

 $packageData = $this->preProcess($driver, $data, $identifier);
 $package = $this->loader->load($packageData);
 if ($this->loader instanceof ValidatingArrayLoader && $this->loader->getWarnings()) {
 throw new InvalidPackageException($this->loader->getErrors(), $this->loader->getWarnings(), $packageData);
 }
 $this->addPackage($package);
 } catch (TransportException $e) {
 if ($verbose) {
 $this->io->writeError('<warning>Skipped branch '.$branch.', no composer file was found</warning>');
 }
 continue;
 } catch (\Exception $e) {
 if (!$verbose) {
 $this->io->writeError('');
 }
 $this->branchErrorOccurred = true;
 $this->io->writeError('<error>Skipped branch '.$branch.', '.$e->getMessage().'</error>');
 $this->io->writeError('');
 continue;
 }
 }
 $driver->cleanup();

 if (!$verbose) {
 $this->io->overwriteError('', false);
 }

 if (!$this->getPackages()) {
 throw new InvalidRepositoryException('No valid composer.json was found in any branch or tag of '.$this->url.', could not load a package from it.');
 }
 }

 protected function preProcess(VcsDriverInterface $driver, array $data, $identifier)
 {

 $data['name'] = $this->packageName ?: $data['name'];

 if (!isset($data['dist'])) {
 $data['dist'] = $driver->getDist($identifier);
 }
 if (!isset($data['source'])) {
 $data['source'] = $driver->getSource($identifier);
 }

 return $data;
 }

 private function validateBranch($branch)
 {
 try {
 return $this->versionParser->normalizeBranch($branch);
 } catch (\Exception $e) {
 }

 return false;
 }

 private function validateTag($version)
 {
 try {
 return $this->versionParser->normalize($version);
 } catch (\Exception $e) {
 }

 return false;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\AliasPackage;






 class WritableArrayRepository extends ArrayRepository implements WritableRepositoryInterface
 {



 public function write()
 {
 }




 public function reload()
 {
 }




 public function getCanonicalPackages()
 {
 $packages = $this->getPackages();


 $packagesByName = array();
 foreach ($packages as $package) {
 if (!isset($packagesByName[$package->getName()]) || $packagesByName[$package->getName()] instanceof AliasPackage) {
 $packagesByName[$package->getName()] = $package;
 }
 }

 $canonicalPackages = array();


 foreach ($packagesByName as $package) {
 while ($package instanceof AliasPackage) {
 $package = $package->getAliasOf();
 }

 $canonicalPackages[] = $package;
 }

 return $canonicalPackages;
 }
 }
 <?php











 namespace Composer\Repository;

 use Composer\Package\PackageInterface;






 interface WritableRepositoryInterface extends RepositoryInterface
 {



 public function write();






 public function addPackage(PackageInterface $package);






 public function removePackage(PackageInterface $package);






 public function getCanonicalPackages();




 public function reload();
 }
 <?php











 namespace Composer\Script;






 class CommandEvent extends Event
 {
 }
 <?php











 namespace Composer\Script;

 use Composer\Composer;
 use Composer\IO\IOInterface;
 use Composer\EventDispatcher\Event as BaseEvent;







 class Event extends BaseEvent
 {



 private $composer;




 private $io;




 private $devMode;











 public function __construct($name, Composer $composer, IOInterface $io, $devMode = false, array $args = array(), array $flags = array())
 {
 parent::__construct($name, $args, $flags);
 $this->composer = $composer;
 $this->io = $io;
 $this->devMode = $devMode;
 }






 public function getComposer()
 {
 return $this->composer;
 }






 public function getIO()
 {
 return $this->io;
 }






 public function isDevMode()
 {
 return $this->devMode;
 }
 }
 <?php











 namespace Composer\Script;

 use Composer\Installer\PackageEvent as BasePackageEvent;






 class PackageEvent extends BasePackageEvent
 {
 }
 <?php











 namespace Composer\Script;







 class ScriptEvents
 {







 const PRE_INSTALL_CMD = 'pre-install-cmd';








 const POST_INSTALL_CMD = 'post-install-cmd';








 const PRE_UPDATE_CMD = 'pre-update-cmd';








 const POST_UPDATE_CMD = 'post-update-cmd';








 const PRE_STATUS_CMD = 'pre-status-cmd';








 const POST_STATUS_CMD = 'post-status-cmd';








 const PRE_AUTOLOAD_DUMP = 'pre-autoload-dump';








 const POST_AUTOLOAD_DUMP = 'post-autoload-dump';








 const POST_ROOT_PACKAGE_INSTALL = 'post-root-package-install';









 const POST_CREATE_PROJECT_CMD = 'post-create-project-cmd';








 const PRE_ARCHIVE_CMD = 'pre-archive-cmd';








 const POST_ARCHIVE_CMD = 'post-archive-cmd';











 const PRE_PACKAGE_INSTALL = 'pre-package-install';









 const POST_PACKAGE_INSTALL = 'post-package-install';









 const PRE_PACKAGE_UPDATE = 'pre-package-update';









 const POST_PACKAGE_UPDATE = 'post-package-update';









 const PRE_PACKAGE_UNINSTALL = 'pre-package-uninstall';









 const POST_PACKAGE_UNINSTALL = 'post-package-uninstall';
 }
 <?php











 namespace Composer\Util;

 use Composer\Config;
 use Composer\IO\IOInterface;




 class AuthHelper
 {
 protected $io;
 protected $config;

 public function __construct(IOInterface $io, Config $config)
 {
 $this->io = $io;
 $this->config = $config;
 }

 public function storeAuth($originUrl, $storeAuth)
 {
 $store = false;
 $configSource = $this->config->getAuthConfigSource();
 if ($storeAuth === true) {
 $store = $configSource;
 } elseif ($storeAuth === 'prompt') {
 $answer = $this->io->askAndValidate(
 'Do you want to store credentials for '.$originUrl.' in '.$configSource->getName().' ? [Yn] ',
 function ($value) {
 $input = strtolower(substr(trim($value), 0, 1));
 if (in_array($input, array('y','n'))) {
 return $input;
 }
 throw new \RuntimeException('Please answer (y)es or (n)o');
 },
 null,
 'y'
 );

 if ($answer === 'y') {
 $store = $configSource;
 }
 }
 if ($store) {
 $store->addConfigSetting(
 'http-basic.'.$originUrl,
 $this->io->getAuthentication($originUrl)
 );
 }
 }
 }
 <?php











 namespace Composer\Util;






 class ComposerMirror
 {
 public static function processUrl($mirrorUrl, $packageName, $version, $reference, $type)
 {
 if ($reference) {
 $reference = preg_match('{^([a-f0-9]*|%reference%)$}', $reference) ? $reference : md5($reference);
 }
 $version = strpos($version, '/') === false ? $version : md5($version);

 return str_replace(
 array('%package%', '%version%', '%reference%', '%type%'),
 array($packageName, $version, $reference, $type),
 $mirrorUrl
 );
 }

 public static function processGitUrl($mirrorUrl, $packageName, $url, $type)
 {
 if (preg_match('#^(?:(?:https?|git)://github\.com/|git@github\.com:)([^/]+)/(.+?)(?:\.git)?$#', $url, $match)) {
 $url = 'gh-'.$match[1].'/'.$match[2];
 } elseif (preg_match('#^https://bitbucket\.org/([^/]+)/(.+?)(?:\.git)?/?$#', $url, $match)) {
 $url = 'bb-'.$match[1].'/'.$match[2];
 } else {
 $url = preg_replace('{[^a-z0-9_.-]}i', '-', trim($url, '/'));
 }

 return str_replace(
 array('%package%', '%normalizedUrl%', '%type%'),
 array($packageName, $url, $type),
 $mirrorUrl
 );
 }

 public static function processHgUrl($mirrorUrl, $packageName, $url, $type)
 {
 return self::processGitUrl($mirrorUrl, $packageName, $url, $type);
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\Package\Loader\ArrayLoader;
 use Composer\Package\Loader\ValidatingArrayLoader;
 use Composer\Package\Loader\InvalidPackageException;
 use Composer\Json\JsonValidationException;
 use Composer\IO\IOInterface;
 use Composer\Json\JsonFile;
 use Composer\Spdx\SpdxLicenses;







 class ConfigValidator
 {
 private $io;

 public function __construct(IOInterface $io)
 {
 $this->io = $io;
 }









 public function validate($file, $arrayLoaderValidationFlags = ValidatingArrayLoader::CHECK_ALL)
 {
 $errors = array();
 $publishErrors = array();
 $warnings = array();


 $laxValid = false;
 try {
 $json = new JsonFile($file, new RemoteFilesystem($this->io));
 $manifest = $json->read();

 $json->validateSchema(JsonFile::LAX_SCHEMA);
 $laxValid = true;
 $json->validateSchema();
 } catch (JsonValidationException $e) {
 foreach ($e->getErrors() as $message) {
 if ($laxValid) {
 $publishErrors[] = $message;
 } else {
 $errors[] = $message;
 }
 }
 } catch (\Exception $e) {
 $errors[] = $e->getMessage();

 return array($errors, $publishErrors, $warnings);
 }


 if (!empty($manifest['license'])) {

 if (is_array($manifest['license'])) {
 foreach ($manifest['license'] as $key => $license) {
 if ('proprietary' === $license) {
 unset($manifest['license'][$key]);
 }
 }
 }

 $licenseValidator = new SpdxLicenses();
 if ('proprietary' !== $manifest['license'] && array() !== $manifest['license'] && !$licenseValidator->validate($manifest['license'])) {
 $warnings[] = sprintf(
 'License %s is not a valid SPDX license identifier, see http://www.spdx.org/licenses/ if you use an open license.'
 ."\nIf the software is closed-source, you may use \"proprietary\" as license.",
 json_encode($manifest['license'])
 );
 }
 } else {
 $warnings[] = 'No license specified, it is recommended to do so. For closed-source software you may use "proprietary" as license.';
 }

 if (isset($manifest['version'])) {
 $warnings[] = 'The version field is present, it is recommended to leave it out if the package is published on Packagist.';
 }

 if (!empty($manifest['name']) && preg_match('{[A-Z]}', $manifest['name'])) {
 $suggestName = preg_replace('{(?:([a-z])([A-Z])|([A-Z])([A-Z][a-z]))}', '\\1\\3-\\2\\4', $manifest['name']);
 $suggestName = strtolower($suggestName);

 $publishErrors[] = sprintf(
 'Name "%s" does not match the best practice (e.g. lower-cased/with-dashes). We suggest using "%s" instead. As such you will not be able to submit it to Packagist.',
 $manifest['name'],
 $suggestName
 );
 }

 if (!empty($manifest['type']) && $manifest['type'] == 'composer-installer') {
 $warnings[] = "The package type 'composer-installer' is deprecated. Please distribute your custom installers as plugins from now on. See http://getcomposer.org/doc/articles/plugins.md for plugin documentation.";
 }


 if (isset($manifest['require']) && isset($manifest['require-dev'])) {
 $requireOverrides = array_intersect_key($manifest['require'], $manifest['require-dev']);

 if (!empty($requireOverrides)) {
 $plural = (count($requireOverrides) > 1) ? 'are' : 'is';
 $warnings[] = implode(', ', array_keys($requireOverrides)). " {$plural} required both in require and require-dev, this can lead to unexpected behavior";
 }
 }

 try {
 $loader = new ValidatingArrayLoader(new ArrayLoader(), true, null, $arrayLoaderValidationFlags);
 if (!isset($manifest['version'])) {
 $manifest['version'] = '1.0.0';
 }
 if (!isset($manifest['name'])) {
 $manifest['name'] = 'dummy/dummy';
 }
 $loader->load($manifest);
 } catch (InvalidPackageException $e) {
 $errors = array_merge($errors, $e->getErrors());
 }

 $warnings = array_merge($warnings, $loader->getWarnings());

 return array($errors, $publishErrors, $warnings);
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\IO\IOInterface;






 class ErrorHandler
 {
 private static $io;












 public static function handle($level, $message, $file, $line)
 {

 if (!error_reporting()) {
 return;
 }

 if (ini_get('xdebug.scream')) {
 $message .= "\n\nWarning: You have xdebug.scream enabled, the warning above may be".
 "\na legitimately suppressed error that you were not supposed to see.";
 }

 if ($level !== E_DEPRECATED && $level !== E_USER_DEPRECATED) {
 throw new \ErrorException($message, 0, $level, $file, $line);
 }

 if (self::$io) {
 self::$io->writeError('<warning>Deprecation Notice: '.$message.' in '.$file.':'.$line.'</warning>');
 if (self::$io->isVerbose()) {
 self::$io->writeError('<warning>Stack trace:</warning>');
 self::$io->writeError(array_filter(array_map(function ($a) {
 if (isset($a['line'], $a['file'])) {
 return '<warning> '.$a['file'].':'.$a['line'].'</warning>';
 }

 return null;
 }, array_slice(debug_backtrace(), 2))));
 }
 }
 }






 public static function register(IOInterface $io = null)
 {
 set_error_handler(array(__CLASS__, 'handle'));
 self::$io = $io;
 }
 }
 <?php











 namespace Composer\Util;

 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use Symfony\Component\Finder\Finder;





 class Filesystem
 {
 private $processExecutor;

 public function __construct(ProcessExecutor $executor = null)
 {
 $this->processExecutor = $executor ?: new ProcessExecutor();
 }

 public function remove($file)
 {
 if (is_dir($file)) {
 return $this->removeDirectory($file);
 }

 if (file_exists($file)) {
 return $this->unlink($file);
 }

 return false;
 }







 public function isDirEmpty($dir)
 {
 $finder = Finder::create()
 ->ignoreVCS(false)
 ->ignoreDotFiles(false)
 ->depth(0)
 ->in($dir);

 return count($finder) === 0;
 }

 public function emptyDirectory($dir, $ensureDirectoryExists = true)
 {
 if (file_exists($dir) && is_link($dir)) {
 $this->unlink($dir);
 }

 if ($ensureDirectoryExists) {
 $this->ensureDirectoryExists($dir);
 }

 if (is_dir($dir)) {
 $finder = Finder::create()
 ->ignoreVCS(false)
 ->ignoreDotFiles(false)
 ->depth(0)
 ->in($dir);

 foreach ($finder as $path) {
 $this->remove((string) $path);
 }
 }
 }












 public function removeDirectory($directory)
 {
 if ($this->isSymlinkedDirectory($directory)) {
 return $this->unlinkSymlinkedDirectory($directory);
 }

 if (!file_exists($directory) || !is_dir($directory)) {
 return true;
 }

 if (preg_match('{^(?:[a-z]:)?[/\\\\]+$}i', $directory)) {
 throw new \RuntimeException('Aborting an attempted deletion of '.$directory.', this was probably not intended, if it is a real use case please report it.');
 }

 if (!function_exists('proc_open')) {
 return $this->removeDirectoryPhp($directory);
 }

 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $cmd = sprintf('rmdir /S /Q %s', ProcessExecutor::escape(realpath($directory)));
 } else {
 $cmd = sprintf('rm -rf %s', ProcessExecutor::escape($directory));
 }

 $result = $this->getProcess()->execute($cmd, $output) === 0;


 clearstatcache();

 if ($result && !file_exists($directory)) {
 return true;
 }

 return $this->removeDirectoryPhp($directory);
 }











 public function removeDirectoryPhp($directory)
 {
 $it = new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS);
 $ri = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);

 foreach ($ri as $file) {
 if ($file->isDir()) {
 $this->rmdir($file->getPathname());
 } else {
 $this->unlink($file->getPathname());
 }
 }

 return $this->rmdir($directory);
 }

 public function ensureDirectoryExists($directory)
 {
 if (!is_dir($directory)) {
 if (file_exists($directory)) {
 throw new \RuntimeException(
 $directory.' exists and is not a directory.'
 );
 }
 if (!@mkdir($directory, 0777, true)) {
 throw new \RuntimeException(
 $directory.' does not exist and could not be created.'
 );
 }
 }
 }









 public function unlink($path)
 {
 if (!@$this->unlinkImplementation($path)) {

 if (!defined('PHP_WINDOWS_VERSION_BUILD') || (usleep(350000) && !@$this->unlinkImplementation($path))) {
 $error = error_get_last();
 $message = 'Could not delete '.$path.': ' . @$error['message'];
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $message .= "\nThis can be due to an antivirus or the Windows Search Indexer locking the file while they are analyzed";
 }

 throw new \RuntimeException($message);
 }
 }

 return true;
 }









 public function rmdir($path)
 {
 if (!@rmdir($path)) {

 if (!defined('PHP_WINDOWS_VERSION_BUILD') || (usleep(350000) && !@rmdir($path))) {
 $error = error_get_last();
 $message = 'Could not delete '.$path.': ' . @$error['message'];
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $message .= "\nThis can be due to an antivirus or the Windows Search Indexer locking the file while they are analyzed";
 }

 throw new \RuntimeException($message);
 }
 }

 return true;
 }










 public function copyThenRemove($source, $target)
 {
 if (!is_dir($source)) {
 copy($source, $target);
 $this->unlink($source);

 return;
 }

 $it = new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS);
 $ri = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::SELF_FIRST);
 $this->ensureDirectoryExists($target);

 foreach ($ri as $file) {
 $targetPath = $target . DIRECTORY_SEPARATOR . $ri->getSubPathName();
 if ($file->isDir()) {
 $this->ensureDirectoryExists($targetPath);
 } else {
 copy($file->getPathname(), $targetPath);
 }
 }

 $this->removeDirectoryPhp($source);
 }

 public function rename($source, $target)
 {
 if (true === @rename($source, $target)) {
 return;
 }

 if (!function_exists('proc_open')) {
 return $this->copyThenRemove($source, $target);
 }

 if (defined('PHP_WINDOWS_VERSION_BUILD')) {

 $command = sprintf('xcopy %s %s /E /I /Q', ProcessExecutor::escape($source), ProcessExecutor::escape($target));
 $result = $this->processExecutor->execute($command, $output);


 clearstatcache();

 if (0 === $result) {
 $this->remove($source);

 return;
 }
 } else {

 
 $command = sprintf('mv %s %s', ProcessExecutor::escape($source), ProcessExecutor::escape($target));
 $result = $this->processExecutor->execute($command, $output);


 clearstatcache();

 if (0 === $result) {
 return;
 }
 }

 return $this->copyThenRemove($source, $target);
 }










 public function findShortestPath($from, $to, $directories = false)
 {
 if (!$this->isAbsolutePath($from) || !$this->isAbsolutePath($to)) {
 throw new \InvalidArgumentException(sprintf('$from (%s) and $to (%s) must be absolute paths.', $from, $to));
 }

 $from = lcfirst($this->normalizePath($from));
 $to = lcfirst($this->normalizePath($to));

 if ($directories) {
 $from = rtrim($from, '/') . '/dummy_file';
 }

 if (dirname($from) === dirname($to)) {
 return './'.basename($to);
 }

 $commonPath = $to;
 while (strpos($from.'/', $commonPath.'/') !== 0 && '/' !== $commonPath && !preg_match('{^[a-z]:/?$}i', $commonPath)) {
 $commonPath = strtr(dirname($commonPath), '\\', '/');
 }

 if (0 !== strpos($from, $commonPath) || '/' === $commonPath) {
 return $to;
 }

 $commonPath = rtrim($commonPath, '/') . '/';
 $sourcePathDepth = substr_count(substr($from, strlen($commonPath)), '/');
 $commonPathCode = str_repeat('../', $sourcePathDepth);

 return ($commonPathCode . substr($to, strlen($commonPath))) ?: './';
 }










 public function findShortestPathCode($from, $to, $directories = false)
 {
 if (!$this->isAbsolutePath($from) || !$this->isAbsolutePath($to)) {
 throw new \InvalidArgumentException(sprintf('$from (%s) and $to (%s) must be absolute paths.', $from, $to));
 }

 $from = lcfirst($this->normalizePath($from));
 $to = lcfirst($this->normalizePath($to));

 if ($from === $to) {
 return $directories ? '__DIR__' : '__FILE__';
 }

 $commonPath = $to;
 while (strpos($from.'/', $commonPath.'/') !== 0 && '/' !== $commonPath && !preg_match('{^[a-z]:/?$}i', $commonPath) && '.' !== $commonPath) {
 $commonPath = strtr(dirname($commonPath), '\\', '/');
 }

 if (0 !== strpos($from, $commonPath) || '/' === $commonPath || '.' === $commonPath) {
 return var_export($to, true);
 }

 $commonPath = rtrim($commonPath, '/') . '/';
 if (strpos($to, $from.'/') === 0) {
 return '__DIR__ . '.var_export(substr($to, strlen($from)), true);
 }
 $sourcePathDepth = substr_count(substr($from, strlen($commonPath)), '/') + $directories;
 $commonPathCode = str_repeat('dirname(', $sourcePathDepth).'__DIR__'.str_repeat(')', $sourcePathDepth);
 $relTarget = substr($to, strlen($commonPath));

 return $commonPathCode . (strlen($relTarget) ? '.' . var_export('/' . $relTarget, true) : '');
 }







 public function isAbsolutePath($path)
 {
 return substr($path, 0, 1) === '/' || substr($path, 1, 1) === ':';
 }









 public function size($path)
 {
 if (!file_exists($path)) {
 throw new \RuntimeException("$path does not exist.");
 }
 if (is_dir($path)) {
 return $this->directorySize($path);
 }

 return filesize($path);
 }








 public function normalizePath($path)
 {
 $parts = array();
 $path = strtr($path, '\\', '/');
 $prefix = '';
 $absolute = false;

 if (preg_match('{^([0-9a-z]+:(?://(?:[a-z]:)?)?)}i', $path, $match)) {
 $prefix = $match[1];
 $path = substr($path, strlen($prefix));
 }

 if (substr($path, 0, 1) === '/') {
 $absolute = true;
 $path = substr($path, 1);
 }

 $up = false;
 foreach (explode('/', $path) as $chunk) {
 if ('..' === $chunk && ($absolute || $up)) {
 array_pop($parts);
 $up = !(empty($parts) || '..' === end($parts));
 } elseif ('.' !== $chunk && '' !== $chunk) {
 $parts[] = $chunk;
 $up = '..' !== $chunk;
 }
 }

 return $prefix.($absolute ? '/' : '').implode('/', $parts);
 }







 public static function isLocalPath($path)
 {
 return (bool) preg_match('{^(file://|/|[a-z]:[\\\\/]|\.\.[\\\\/]|[a-z0-9_.-]+[\\\\/])}i', $path);
 }

 public static function getPlatformPath($path)
 {
 if (defined('PHP_WINDOWS_VERSION_BUILD')) {
 $path = preg_replace('{^(?:file:///([a-z])/)}i', 'file://$1:/', $path);
 }

 return preg_replace('{^file://}i', '', $path);
 }

 protected function directorySize($directory)
 {
 $it = new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS);
 $ri = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);

 $size = 0;
 foreach ($ri as $file) {
 if ($file->isFile()) {
 $size += $file->getSize();
 }
 }

 return $size;
 }

 protected function getProcess()
 {
 return new ProcessExecutor;
 }










 private function unlinkImplementation($path)
 {
 if (defined('PHP_WINDOWS_VERSION_BUILD') && is_dir($path) && is_link($path)) {
 return rmdir($path);
 }

 return unlink($path);
 }

 private function isSymlinkedDirectory($directory)
 {
 if (!is_dir($directory)) {
 return false;
 }

 $resolved = $this->resolveSymlinkedDirectorySymlink($directory);

 return is_link($resolved);
 }






 private function unlinkSymlinkedDirectory($directory)
 {
 $resolved = $this->resolveSymlinkedDirectorySymlink($directory);

 return $this->unlink($resolved);
 }








 private function resolveSymlinkedDirectorySymlink($pathname)
 {
 if (!is_dir($pathname)) {
 return $pathname;
 }

 $resolved = rtrim($pathname, '/');

 if (!strlen($resolved)) {
 return $pathname;
 }

 return $resolved;
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\Config;
 use Composer\IO\IOInterface;




 class Git
 {
 protected $io;
 protected $config;
 protected $process;
 protected $filesystem;

 public function __construct(IOInterface $io, Config $config, ProcessExecutor $process, Filesystem $fs)
 {
 $this->io = $io;
 $this->config = $config;
 $this->process = $process;
 $this->filesystem = $fs;
 }

 public function runCommand($commandCallable, $url, $cwd, $initialClone = false)
 {
 if ($initialClone) {
 $origCwd = $cwd;
 $cwd = null;
 }

 if (preg_match('{^ssh://[^@]+@[^:]+:[^0-9]+}', $url)) {
 throw new \InvalidArgumentException('The source URL '.$url.' is invalid, ssh URLs should have a port number after ":".'."\n".'Use ssh://[email protected]:22/path or just [email protected]:path if you do not want to provide a password or custom port.');
 }

 if (!$initialClone) {

 $this->process->execute('git remote -v', $output, $cwd);
 if (preg_match('{^(?:composer|origin)\s+https?://(.+):(.+)@([^/]+)}im', $output, $match)) {
 $this->io->setAuthentication($match[3], urldecode($match[1]), urldecode($match[2]));
 }
 }

 $protocols = $this->config->get('github-protocols');
 if (!is_array($protocols)) {
 throw new \RuntimeException('Config value "github-protocols" must be an array, got '.gettype($protocols));
 }


 if (preg_match('{^(?:https?|git)://'.self::getGitHubDomainsRegex($this->config).'/(.*)}', $url, $match)) {
 $messages = array();
 foreach ($protocols as $protocol) {
 if ('ssh' === $protocol) {
 $url = "git@" . $match[1] . ":" . $match[2];
 } else {
 $url = $protocol ."://" . $match[1] . "/" . $match[2];
 }

 if (0 === $this->process->execute(call_user_func($commandCallable, $url), $ignoredOutput, $cwd)) {
 return;
 }
 $messages[] = '- ' . $url . "\n" . preg_replace('#^#m', '  ', $this->process->getErrorOutput());
 if ($initialClone) {
 $this->filesystem->removeDirectory($origCwd);
 }
 }


 $this->throwException('Failed to clone ' . self::sanitizeUrl($url) .' via '.implode(', ', $protocols).' protocols, aborting.' . "\n\n" . implode("\n", $messages), $url);
 }


 $bypassSshForGitHub = preg_match('{^git@'.self::getGitHubDomainsRegex($this->config).':(.+?)\.git$}i', $url) && !in_array('ssh', $protocols, true);

 $command = call_user_func($commandCallable, $url);
 if ($bypassSshForGitHub || 0 !== $this->process->execute($command, $ignoredOutput, $cwd)) {

 if (preg_match('{^git@'.self::getGitHubDomainsRegex($this->config).':(.+?)\.git$}i', $url, $match)) {
 if (!$this->io->hasAuthentication($match[1])) {
 $gitHubUtil = new GitHub($this->io, $this->config, $this->process);
 $message = 'Cloning failed using an ssh key for authentication, enter your GitHub credentials to access private repos';

 if (!$gitHubUtil->authorizeOAuth($match[1]) && $this->io->isInteractive()) {
 $gitHubUtil->authorizeOAuthInteractively($match[1], $message);
 }
 }

 if ($this->io->hasAuthentication($match[1])) {
 $auth = $this->io->getAuthentication($match[1]);
 $url = 'https://'.rawurlencode($auth['username']) . ':' . rawurlencode($auth['password']) . '@'.$match[1].'/'.$match[2].'.git';

 $command = call_user_func($commandCallable, $url);
 if (0 === $this->process->execute($command, $ignoredOutput, $cwd)) {
 return;
 }
 }
 } elseif ( 
 $this->isAuthenticationFailure($url, $match)
 ) {
 if (strpos($match[2], '@')) {
 list($authParts, $match[2]) = explode('@', $match[2], 2);
 }

 $storeAuth = false;
 if ($this->io->hasAuthentication($match[2])) {
 $auth = $this->io->getAuthentication($match[2]);
 } elseif ($this->io->isInteractive()) {
 $defaultUsername = null;
 if (isset($authParts) && $authParts) {
 if (false !== strpos($authParts, ':')) {
 list($defaultUsername,) = explode(':', $authParts, 2);
 } else {
 $defaultUsername = $authParts;
 }
 }

 $this->io->writeError('    Authentication required (<info>'.parse_url($url, PHP_URL_HOST).'</info>):');
 $auth = array(
 'username' => $this->io->ask('      Username: ', $defaultUsername),
 'password' => $this->io->askAndHideAnswer('      Password: '),
 );
 $storeAuth = $this->config->get('store-auths');
 }

 if ($auth) {
 $url = $match[1].rawurlencode($auth['username']).':'.rawurlencode($auth['password']).'@'.$match[2].$match[3];

 $command = call_user_func($commandCallable, $url);
 if (0 === $this->process->execute($command, $ignoredOutput, $cwd)) {
 $this->io->setAuthentication($match[2], $auth['username'], $auth['password']);
 $authHelper = new AuthHelper($this->io, $this->config);
 $authHelper->storeAuth($match[2], $storeAuth);

 return;
 }
 }
 }

 if ($initialClone) {
 $this->filesystem->removeDirectory($origCwd);
 }
 $this->throwException('Failed to execute ' . self::sanitizeUrl($command) . "\n\n" . $this->process->getErrorOutput(), $url);
 }
 }

 private function isAuthenticationFailure($url, &$match)
 {
 if (!preg_match('{(https?://)([^/]+)(.*)$}i', $url, $match)) {
 return false;
 }

 $authFailures = array('fatal: Authentication failed', 'remote error: Invalid username or password.');
 foreach ($authFailures as $authFailure) {
 if (strpos($this->process->getErrorOutput(), $authFailure) !== false) {
 return true;
 }
 }

 return false;
 }

 public static function cleanEnv()
 {
 if (ini_get('safe_mode') && false === strpos(ini_get('safe_mode_allowed_env_vars'), 'GIT_ASKPASS')) {
 throw new \RuntimeException('safe_mode is enabled and safe_mode_allowed_env_vars does not contain GIT_ASKPASS, can not set env var. You can disable safe_mode with "-dsafe_mode=0" when running composer');
 }


 if (getenv('GIT_ASKPASS') !== 'echo') {
 putenv('GIT_ASKPASS=echo');
 unset($_SERVER['GIT_ASKPASS']);
 }


 if (getenv('GIT_DIR')) {
 putenv('GIT_DIR');
 unset($_SERVER['GIT_DIR']);
 }
 if (getenv('GIT_WORK_TREE')) {
 putenv('GIT_WORK_TREE');
 unset($_SERVER['GIT_WORK_TREE']);
 }


 if (getenv('LANGUAGE') !== 'C') {
 putenv('LANGUAGE=C');
 }


 putenv("DYLD_LIBRARY_PATH");
 unset($_SERVER['DYLD_LIBRARY_PATH']);
 }

 public static function getGitHubDomainsRegex(Config $config)
 {
 return '('.implode('|', array_map('preg_quote', $config->get('github-domains'))).')';
 }

 public static function sanitizeUrl($message)
 {
 return preg_replace('{://([^@]+?):.+?@}', '://$1:***@', $message);
 }

 private function throwException($message, $url)
 {

 clearstatcache();

 if (0 !== $this->process->execute('git --version', $ignoredOutput)) {
 throw new \RuntimeException('Failed to clone '.self::sanitizeUrl($url).', git was not found, check that it is installed and in your PATH env.' . "\n\n" . $this->process->getErrorOutput());
 }

 throw new \RuntimeException($message);
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\IO\IOInterface;
 use Composer\Config;
 use Composer\Downloader\TransportException;




 class GitHub
 {
 protected $io;
 protected $config;
 protected $process;
 protected $remoteFilesystem;









 public function __construct(IOInterface $io, Config $config, ProcessExecutor $process = null, RemoteFilesystem $remoteFilesystem = null)
 {
 $this->io = $io;
 $this->config = $config;
 $this->process = $process ?: new ProcessExecutor;
 $this->remoteFilesystem = $remoteFilesystem ?: new RemoteFilesystem($io, $config);
 }







 public function authorizeOAuth($originUrl)
 {
 if (!in_array($originUrl, $this->config->get('github-domains'))) {
 return false;
 }


 if (0 === $this->process->execute('git config github.accesstoken', $output)) {
 $this->io->setAuthentication($originUrl, trim($output), 'x-oauth-basic');

 return true;
 }

 return false;
 }










 public function authorizeOAuthInteractively($originUrl, $message = null)
 {
 if ($message) {
 $this->io->writeError($message);
 }

 $note = 'Composer';
 if ($this->config->get('github-expose-hostname') === true && 0 === $this->process->execute('hostname', $output)) {
 $note .= ' on ' . trim($output);
 }
 $note .= ' ' . date('Y-m-d Hi');

 $url = 'https://'.$originUrl.'/settings/tokens/new?scopes=repo&description=' . str_replace('%20', '+', rawurlencode($note));
 $this->io->writeError(sprintf('Head to %s', $url));
 $this->io->writeError(sprintf('to retrieve a token. It will be stored in "%s" for future use by Composer.', $this->config->getAuthConfigSource()->getName()));

 $token = trim($this->io->askAndHideAnswer('Token (hidden): '));

 if (!$token) {
 $this->io->writeError('<warning>No token given, aborting.</warning>');
 $this->io->writeError('You can also add it manually later by using "composer config github-oauth.github.com <token>"');

 return false;
 }

 $this->io->setAuthentication($originUrl, $token, 'x-oauth-basic');

 try {
 $apiUrl = ('github.com' === $originUrl) ? 'api.github.com' : $originUrl . '/api/v3';

 $this->remoteFilesystem->getContents($originUrl, 'https://'. $apiUrl . '/rate_limit', false, array(
 'retry-auth-failure' => false,
 ));
 } catch (TransportException $e) {
 if (in_array($e->getCode(), array(403, 401))) {
 $this->io->writeError('<error>Invalid token provided.</error>');
 $this->io->writeError('You can also add it manually later by using "composer config github-oauth.github.com <token>"');

 return false;
 }

 throw $e;
 }


 $this->config->getConfigSource()->removeConfigSetting('github-oauth.'.$originUrl);
 $this->config->getAuthConfigSource()->addConfigSetting('github-oauth.'.$originUrl, $token);

 $this->io->writeError('<info>Token stored successfully.</info>');

 return true;
 }
 }
 <?php











 namespace Composer\Util;




 class NoProxyPattern
 {



 protected $rules = array();




 public function __construct($pattern)
 {
 $this->rules = preg_split("/[\s,]+/", $pattern);
 }








 public function test($url)
 {
 $host = parse_url($url, PHP_URL_HOST);
 $port = parse_url($url, PHP_URL_PORT);

 if (empty($port)) {
 switch (parse_url($url, PHP_URL_SCHEME)) {
 case 'http':
 $port = 80;
 break;
 case 'https':
 $port = 443;
 break;
 }
 }

 foreach ($this->rules as $rule) {
 if ($rule == '*') {
 return true;
 }

 $match = false;

 list($ruleHost) = explode(':', $rule);
 list($base) = explode('/', $ruleHost);

 if (filter_var($base, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {


 if (!isset($ip)) {
 $ip = gethostbyname($host);
 }

 if (strpos($ruleHost, '/') === false) {
 $match = $ip === $ruleHost;
 } else {

 
 if ($ip === $host) {
 $match = false;
 } else {

 $match = self::inCIDRBlock($ruleHost, $ip);
 }
 }
 } else {


 $haystack = '.' . trim($host, '.') . '.';
 $needle = '.'. trim($ruleHost, '.') .'.';
 $match = stripos(strrev($haystack), strrev($needle)) === 0;
 }


 if ($match && strpos($rule, ':') !== false) {
 list(, $rulePort) = explode(':', $rule);
 if (!empty($rulePort) && $port != $rulePort) {
 $match = false;
 }
 }

 if ($match) {
 return true;
 }
 }

 return false;
 }











 private static function inCIDRBlock($cidr, $ip)
 {

 list($base, $bits) = explode('/', $cidr);


 list($a, $b, $c, $d) = explode('.', $base);


 $i = ($a << 24) + ($b << 16) + ($c << 8) + $d;
 $mask = $bits == 0 ? 0 : (~0 << (32 - $bits));


 $low = $i & $mask;


 $high = $i | (~$mask & 0xFFFFFFFF);


 list($a, $b, $c, $d) = explode('.', $ip);


 $check = ($a << 24) + ($b << 16) + ($c << 8) + $d;


 
 return $check >= $low && $check <= $high;
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\IO\IOInterface;
 use Symfony\Component\Process\Process;




 class Perforce
 {
 protected $path;
 protected $p4Depot;
 protected $p4Client;
 protected $p4User;
 protected $p4Password;
 protected $p4Port;
 protected $p4Stream;
 protected $p4ClientSpec;
 protected $p4DepotType;
 protected $p4Branch;
 protected $process;
 protected $uniquePerforceClientName;
 protected $windowsFlag;
 protected $commandResult;

 protected $io;

 protected $filesystem;

 public function __construct($repoConfig, $port, $path, ProcessExecutor $process, $isWindows, IOInterface $io)
 {
 $this->windowsFlag = $isWindows;
 $this->p4Port = $port;
 $this->initializePath($path);
 $this->process = $process;
 $this->initialize($repoConfig);
 $this->io = $io;
 }

 public static function create($repoConfig, $port, $path, ProcessExecutor $process, IOInterface $io)
 {
 $isWindows = defined('PHP_WINDOWS_VERSION_BUILD');
 $perforce = new Perforce($repoConfig, $port, $path, $process, $isWindows, $io);

 return $perforce;
 }

 public static function checkServerExists($url, ProcessExecutor $processExecutor)
 {
 $output = null;

 return 0 === $processExecutor->execute('p4 -p ' . $url . ' info -s', $output);
 }

 public function initialize($repoConfig)
 {
 $this->uniquePerforceClientName = $this->generateUniquePerforceClientName();
 if (null == $repoConfig) {
 return;
 }
 if (isset($repoConfig['unique_perforce_client_name'])) {
 $this->uniquePerforceClientName = $repoConfig['unique_perforce_client_name'];
 }

 if (isset($repoConfig['depot'])) {
 $this->p4Depot = $repoConfig['depot'];
 }
 if (isset($repoConfig['branch'])) {
 $this->p4Branch = $repoConfig['branch'];
 }
 if (isset($repoConfig['p4user'])) {
 $this->p4User = $repoConfig['p4user'];
 } else {
 $this->p4User = $this->getP4variable('P4USER');
 }
 if (isset($repoConfig['p4password'])) {
 $this->p4Password = $repoConfig['p4password'];
 }
 }

 public function initializeDepotAndBranch($depot, $branch)
 {
 if (isset($depot)) {
 $this->p4Depot = $depot;
 }
 if (isset($branch)) {
 $this->p4Branch = $branch;
 }
 }

 public function generateUniquePerforceClientName()
 {
 return gethostname() . "_" . time();
 }

 public function cleanupClientSpec()
 {
 $client = $this->getClient();
 $task = 'client -d ' . $client;
 $useP4Client = false;
 $command = $this->generateP4Command($task, $useP4Client);
 $this->executeCommand($command);
 $clientSpec = $this->getP4ClientSpec();
 $fileSystem = $this->getFilesystem();
 $fileSystem->remove($clientSpec);
 }

 protected function executeCommand($command)
 {
 $this->commandResult = "";
 $exit_code = $this->process->execute($command, $this->commandResult);

 return $exit_code;
 }

 public function getClient()
 {
 if (!isset($this->p4Client)) {
 $cleanStreamName = str_replace('@', '', str_replace('/', '_', str_replace('//', '', $this->getStream())));
 $this->p4Client = 'composer_perforce_' . $this->uniquePerforceClientName . '_' . $cleanStreamName;
 }

 return $this->p4Client;
 }

 protected function getPath()
 {
 return $this->path;
 }

 public function initializePath($path)
 {
 $this->path = $path;
 $fs = $this->getFilesystem();
 $fs->ensureDirectoryExists($path);
 }

 protected function getPort()
 {
 return $this->p4Port;
 }

 public function setStream($stream)
 {
 $this->p4Stream = $stream;
 $index = strrpos($stream, '/');

 if ($index > 2) {
 $this->p4DepotType = 'stream';
 }
 }

 public function isStream()
 {
 return (strcmp($this->p4DepotType, 'stream') === 0);
 }

 public function getStream()
 {
 if (!isset($this->p4Stream)) {
 if ($this->isStream()) {
 $this->p4Stream = '//' . $this->p4Depot . '/' . $this->p4Branch;
 } else {
 $this->p4Stream = '//' . $this->p4Depot;
 }
 }

 return $this->p4Stream;
 }

 public function getStreamWithoutLabel($stream)
 {
 $index = strpos($stream, '@');
 if ($index === false) {
 return $stream;
 }

 return substr($stream, 0, $index);
 }

 public function getP4ClientSpec()
 {
 $p4clientSpec = $this->path . '/' . $this->getClient() . '.p4.spec';

 return $p4clientSpec;
 }

 public function getUser()
 {
 return $this->p4User;
 }

 public function setUser($user)
 {
 $this->p4User = $user;
 }

 public function queryP4User()
 {
 $this->getUser();
 if (strlen($this->p4User) > 0) {
 return;
 }
 $this->p4User = $this->getP4variable('P4USER');
 if (strlen($this->p4User) > 0) {
 return;
 }
 $this->p4User = $this->io->ask('Enter P4 User:');
 if ($this->windowsFlag) {
 $command = 'p4 set P4USER=' . $this->p4User;
 } else {
 $command = 'export P4USER=' . $this->p4User;
 }
 $this->executeCommand($command);
 }

 protected function getP4variable($name)
 {
 if ($this->windowsFlag) {
 $command = 'p4 set';
 $this->executeCommand($command);
 $result = trim($this->commandResult);
 $resArray = explode(PHP_EOL, $result);
 foreach ($resArray as $line) {
 $fields = explode('=', $line);
 if (strcmp($name, $fields[0]) == 0) {
 $index = strpos($fields[1], ' ');
 if ($index === false) {
 $value = $fields[1];
 } else {
 $value = substr($fields[1], 0, $index);
 }
 $value = trim($value);

 return $value;
 }
 }
 } else {
 $command = 'echo $' . $name;
 $this->executeCommand($command);
 $result = trim($this->commandResult);

 return $result;
 }
 }

 public function queryP4Password()
 {
 if (isset($this->p4Password)) {
 return $this->p4Password;
 }
 $password = $this->getP4variable('P4PASSWD');
 if (strlen($password) <= 0) {
 $password = $this->io->askAndHideAnswer('Enter password for Perforce user ' . $this->getUser() . ': ');
 }
 $this->p4Password = $password;

 return $password;
 }

 public function generateP4Command($command, $useClient = true)
 {
 $p4Command = 'p4 ';
 $p4Command = $p4Command . '-u ' . $this->getUser() . ' ';
 if ($useClient) {
 $p4Command = $p4Command . '-c ' . $this->getClient() . ' ';
 }
 $p4Command = $p4Command . '-p ' . $this->getPort() . ' ';
 $p4Command = $p4Command . $command;

 return $p4Command;
 }

 public function isLoggedIn()
 {
 $command = $this->generateP4Command('login -s', false);
 $exitCode = $this->executeCommand($command);
 if ($exitCode) {
 $errorOutput = $this->process->getErrorOutput();
 $index = strpos($errorOutput, $this->getUser());
 if ($index === false) {
 $index = strpos($errorOutput, 'p4');
 if ($index === false) {
 return false;
 }
 throw new \Exception('p4 command not found in path: ' . $errorOutput);
 }
 throw new \Exception('Invalid user name: ' . $this->getUser() );
 }

 return true;
 }

 public function connectClient()
 {
 $p4CreateClientCommand = $this->generateP4Command('client -i < ' . str_replace( " ", "\\ ", $this->getP4ClientSpec() ));
 $this->executeCommand($p4CreateClientCommand);
 }

 public function syncCodeBase($sourceReference)
 {
 $prevDir = getcwd();
 chdir($this->path);
 $p4SyncCommand = $this->generateP4Command('sync -f ');
 if (null != $sourceReference) {
 $p4SyncCommand = $p4SyncCommand . '@' . $sourceReference;
 }
 $this->executeCommand($p4SyncCommand);
 chdir($prevDir);
 }

 public function writeClientSpecToFile($spec)
 {
 fwrite($spec, 'Client: ' . $this->getClient() . PHP_EOL . PHP_EOL);
 fwrite($spec, 'Update: ' . date('Y/m/d H:i:s') . PHP_EOL . PHP_EOL);
 fwrite($spec, 'Access: ' . date('Y/m/d H:i:s') . PHP_EOL);
 fwrite($spec, 'Owner:  ' . $this->getUser() . PHP_EOL . PHP_EOL);
 fwrite($spec, 'Description:' . PHP_EOL);
 fwrite($spec, '  Created by ' . $this->getUser() . ' from composer.' . PHP_EOL . PHP_EOL);
 fwrite($spec, 'Root: ' . $this->getPath() . PHP_EOL . PHP_EOL);
 fwrite($spec, 'Options:  noallwrite noclobber nocompress unlocked modtime rmdir' . PHP_EOL . PHP_EOL);
 fwrite($spec, 'SubmitOptions:  revertunchanged' . PHP_EOL . PHP_EOL);
 fwrite($spec, 'LineEnd:  local' . PHP_EOL . PHP_EOL);
 if ($this->isStream()) {
 fwrite($spec, 'Stream:' . PHP_EOL);
 fwrite($spec, '  ' . $this->getStreamWithoutLabel($this->p4Stream) . PHP_EOL);
 } else {
 fwrite(
 $spec,
 'View:  ' . $this->getStream() . '/...  //' . $this->getClient() . '/... ' . PHP_EOL
 );
 }
 }

 public function writeP4ClientSpec()
 {
 $clientSpec = $this->getP4ClientSpec();
 $spec = fopen($clientSpec, 'w');
 try {
 $this->writeClientSpecToFile($spec);
 } catch (\Exception $e) {
 fclose($spec);
 throw $e;
 }
 fclose($spec);
 }

 protected function read($pipe, $name)
 {
 if (feof($pipe)) {
 return;
 }
 $line = fgets($pipe);
 while ($line != false) {
 $line = fgets($pipe);
 }

 return;
 }

 public function windowsLogin($password)
 {
 $command = $this->generateP4Command(' login -a');
 $process = new Process($command, null, null, $password);

 return $process->run();
 }

 public function p4Login()
 {
 $this->queryP4User();
 if (!$this->isLoggedIn()) {
 $password = $this->queryP4Password();
 if ($this->windowsFlag) {
 $this->windowsLogin($password);
 } else {
 $command = 'echo ' . $password . ' | ' . $this->generateP4Command(' login -a', false);
 $exitCode = $this->executeCommand($command);
 $result = trim($this->commandResult);
 if ($exitCode) {
 throw new \Exception("Error logging in:" . $this->process->getErrorOutput());
 }
 }
 }
 }

 public function getComposerInformation($identifier)
 {
 $index = strpos($identifier, '@');
 if ($index === false) {
 $composerJson = $identifier. '/composer.json';

 return $this->getComposerInformationFromPath($composerJson);
 }

 return $this->getComposerInformationFromLabel($identifier, $index);
 }

 public function getComposerInformationFromPath($composerJson)
 {
 $command = $this->generateP4Command(' print ' . $composerJson);
 $this->executeCommand($command);
 $result = $this->commandResult;
 $index = strpos($result, '{');
 if ($index === false) {
 return '';
 }
 if ($index >= 0) {
 $rawData = substr($result, $index);
 $composer_info = json_decode($rawData, true);

 return $composer_info;
 }

 return '';
 }

 public function getComposerInformationFromLabel($identifier, $index)
 {
 $composerJsonPath = substr($identifier, 0, $index) . '/composer.json' . substr($identifier, $index);
 $command = $this->generateP4Command(' files ' . $composerJsonPath, false);
 $this->executeCommand($command);
 $result = $this->commandResult;
 $index2 = strpos($result, 'no such file(s).');
 if ($index2 === false) {
 $index3 = strpos($result, 'change');
 if (!($index3 === false)) {
 $phrase = trim(substr($result, $index3));
 $fields = explode(' ', $phrase);
 $id = $fields[1];
 $composerJson = substr($identifier, 0, $index) . '/composer.json@' . $id;

 return $this->getComposerInformationFromPath($composerJson);
 }
 }

 return "";
 }

 public function getBranches()
 {
 $possibleBranches = array();
 if (!$this->isStream()) {
 $possibleBranches[$this->p4Branch] = $this->getStream();
 } else {
 $command = $this->generateP4Command('streams //' . $this->p4Depot . '/...');
 $this->executeCommand($command);
 $result = $this->commandResult;
 $resArray = explode(PHP_EOL, $result);
 foreach ($resArray as $line) {
 $resBits = explode(' ', $line);
 if (count($resBits) > 4) {
 $branch = preg_replace('/[^A-Za-z0-9 ]/', '', $resBits[4]);
 $possibleBranches[$branch] = $resBits[1];
 }
 }
 }
 $command = $this->generateP4Command('changes '. $this->getStream() . '/...', false);
 $this->executeCommand($command);
 $result = $this->commandResult;
 $resArray = explode(PHP_EOL, $result);
 $lastCommit = $resArray[0];
 $lastCommitArr = explode(' ', $lastCommit);
 $lastCommitNum = $lastCommitArr[1];

 $branches = array('master' => $possibleBranches[$this->p4Branch] . '@'. $lastCommitNum);

 return $branches;
 }

 public function getTags()
 {
 $command = $this->generateP4Command('labels');
 $this->executeCommand($command);
 $result = $this->commandResult;
 $resArray = explode(PHP_EOL, $result);
 $tags = array();
 foreach ($resArray as $line) {
 $index = strpos($line, 'Label');
 if (!($index === false)) {
 $fields = explode(' ', $line);
 $tags[$fields[1]] = $this->getStream() . '@' . $fields[1];
 }
 }

 return $tags;
 }

 public function checkStream()
 {
 $command = $this->generateP4Command('depots', false);
 $this->executeCommand($command);
 $result = $this->commandResult;
 $resArray = explode(PHP_EOL, $result);
 foreach ($resArray as $line) {
 $index = strpos($line, 'Depot');
 if (!($index === false)) {
 $fields = explode(' ', $line);
 if (strcmp($this->p4Depot, $fields[1]) === 0) {
 $this->p4DepotType = $fields[3];

 return $this->isStream();
 }
 }
 }

 return false;
 }

 protected function getChangeList($reference)
 {
 $index = strpos($reference, '@');
 if ($index === false) {
 return;
 }
 $label = substr($reference, $index);
 $command = $this->generateP4Command(' changes -m1 ' . $label);
 $this->executeCommand($command);
 $changes = $this->commandResult;
 if (strpos($changes, 'Change') !== 0) {
 return;
 }
 $fields = explode(' ', $changes);
 $changeList = $fields[1];

 return $changeList;
 }

 public function getCommitLogs($fromReference, $toReference)
 {
 $fromChangeList = $this->getChangeList($fromReference);
 if ($fromChangeList == null) {
 return;
 }
 $toChangeList = $this->getChangeList($toReference);
 if ($toChangeList == null) {
 return;
 }
 $index = strpos($fromReference, '@');
 $main = substr($fromReference, 0, $index) . '/...';
 $command = $this->generateP4Command('filelog ' . $main . '@' . $fromChangeList. ',' . $toChangeList);
 $this->executeCommand($command);
 $result = $this->commandResult;

 return $result;
 }

 public function getFilesystem()
 {
 if (empty($this->filesystem)) {
 $this->filesystem = new Filesystem($this->process);
 }

 return $this->filesystem;
 }

 public function setFilesystem(Filesystem $fs)
 {
 $this->filesystem = $fs;
 }
 }
 <?php











 namespace Composer\Util;

 use Symfony\Component\Process\Process;
 use Symfony\Component\Process\ProcessUtils;
 use Composer\IO\IOInterface;




 class ProcessExecutor
 {
 protected static $timeout = 300;

 protected $captureOutput;
 protected $errorOutput;
 protected $io;

 public function __construct(IOInterface $io = null)
 {
 $this->io = $io;
 }










 public function execute($command, &$output = null, $cwd = null)
 {
 if ($this->io && $this->io->isDebug()) {
 $safeCommand = preg_replace('{(://[^:/\s]+:)[^@\s/]+}i', '$1****', $command);
 $this->io->writeError('Executing command ('.($cwd ?: 'CWD').'): '.$safeCommand);
 }


 
 if (null === $cwd && defined('PHP_WINDOWS_VERSION_BUILD') && false !== strpos($command, 'git') && getcwd()) {
 $cwd = realpath(getcwd());
 }

 $this->captureOutput = count(func_get_args()) > 1;
 $this->errorOutput = null;
 $process = new Process($command, $cwd, null, null, static::getTimeout());

 $callback = is_callable($output) ? $output : array($this, 'outputHandler');
 $process->run($callback);

 if ($this->captureOutput && !is_callable($output)) {
 $output = $process->getOutput();
 }

 $this->errorOutput = $process->getErrorOutput();

 return $process->getExitCode();
 }

 public function splitLines($output)
 {
 $output = trim($output);

 return ((string) $output === '') ? array() : preg_split('{\r?\n}', $output);
 }






 public function getErrorOutput()
 {
 return $this->errorOutput;
 }

 public function outputHandler($type, $buffer)
 {
 if ($this->captureOutput) {
 return;
 }

 echo $buffer;
 }

 public static function getTimeout()
 {
 return static::$timeout;
 }

 public static function setTimeout($timeout)
 {
 static::$timeout = $timeout;
 }









 public static function escape($argument)
 {
 return ProcessUtils::escapeArgument($argument);
 }
 }
 <?php











 namespace Composer\Util;

 use Composer\Composer;
 use Composer\Config;
 use Composer\IO\IOInterface;
 use Composer\Downloader\TransportException;






 class RemoteFilesystem
 {
 private $io;
 private $config;
 private $bytesMax;
 private $originUrl;
 private $fileUrl;
 private $fileName;
 private $retry;
 private $progress;
 private $lastProgress;
 private $options;
 private $retryAuthFailure;
 private $lastHeaders;
 private $storeAuth;
 private $degradedMode = false;








 public function __construct(IOInterface $io, Config $config = null, array $options = array())
 {
 $this->io = $io;
 $this->config = $config;
 $this->options = $options;
 }












 public function copy($originUrl, $fileUrl, $fileName, $progress = true, $options = array())
 {
 return $this->get($originUrl, $fileUrl, $options, $fileName, $progress);
 }











 public function getContents($originUrl, $fileUrl, $progress = true, $options = array())
 {
 return $this->get($originUrl, $fileUrl, $options, null, $progress);
 }






 public function getOptions()
 {
 return $this->options;
 }






 public function getLastHeaders()
 {
 return $this->lastHeaders;
 }















 protected function get($originUrl, $fileUrl, $additionalOptions = array(), $fileName = null, $progress = true)
 {
 if (strpos($originUrl, '.github.com') === (strlen($originUrl) - 11)) {
 $originUrl = 'github.com';
 }

 $this->bytesMax = 0;
 $this->originUrl = $originUrl;
 $this->fileUrl = $fileUrl;
 $this->fileName = $fileName;
 $this->progress = $progress;
 $this->lastProgress = null;
 $this->retryAuthFailure = true;
 $this->lastHeaders = array();


 if (preg_match('{^https?://(.+):(.+)@([^/]+)}i', $fileUrl, $match)) {
 $this->io->setAuthentication($originUrl, urldecode($match[1]), urldecode($match[2]));
 }

 if (isset($additionalOptions['retry-auth-failure'])) {
 $this->retryAuthFailure = (bool) $additionalOptions['retry-auth-failure'];

 unset($additionalOptions['retry-auth-failure']);
 }

 $options = $this->getOptionsForUrl($originUrl, $additionalOptions);

 if ($this->io->isDebug()) {
 $this->io->writeError((substr($fileUrl, 0, 4) === 'http' ? 'Downloading ' : 'Reading ') . $fileUrl);
 }
 if (isset($options['github-token'])) {
 $fileUrl .= (false === strpos($fileUrl, '?') ? '?' : '&') . 'access_token='.$options['github-token'];
 unset($options['github-token']);
 }
 if (isset($options['http'])) {
 $options['http']['ignore_errors'] = true;
 }
 if ($this->degradedMode && substr($fileUrl, 0, 21) === 'http://packagist.org/') {

 $fileUrl = 'http://' . gethostbyname('packagist.org') . substr($fileUrl, 20);
 }
 $ctx = StreamContextFactory::getContext($fileUrl, $options, array('notification' => array($this, 'callbackGet')));

 if ($this->progress) {
 $this->io->writeError("    Downloading: <comment>Connecting...</comment>", false);
 }

 $errorMessage = '';
 $errorCode = 0;
 $result = false;
 set_error_handler(function ($code, $msg) use (&$errorMessage) {
 if ($errorMessage) {
 $errorMessage .= "\n";
 }
 $errorMessage .= preg_replace('{^file_get_contents\(.*?\): }', '', $msg);
 });
 try {
 $result = file_get_contents($fileUrl, false, $ctx);
 } catch (\Exception $e) {
 if ($e instanceof TransportException && !empty($http_response_header[0])) {
 $e->setHeaders($http_response_header);
 }
 if ($e instanceof TransportException && $result !== false) {
 $e->setResponse($result);
 }
 $result = false;
 }
 if ($errorMessage && !ini_get('allow_url_fopen')) {
 $errorMessage = 'allow_url_fopen must be enabled in php.ini ('.$errorMessage.')';
 }
 restore_error_handler();
 if (isset($e) && !$this->retry) {
 if (!$this->degradedMode && false !== strpos($e->getMessage(), 'Operation timed out')) {
 $this->degradedMode = true;
 $this->io->writeError(array(
 '<error>'.$e->getMessage().'</error>',
 '<error>Retrying with degraded mode, check https://getcomposer.org/doc/articles/troubleshooting.md#degraded-mode for more info</error>'
 ));

 return $this->get($this->originUrl, $this->fileUrl, $additionalOptions, $this->fileName, $this->progress);
 }

 throw $e;
 }


 if (!empty($http_response_header[0]) && preg_match('{^HTTP/\S+ ([45]\d\d)}i', $http_response_header[0], $match)) {
 $errorCode = $match[1];
 if (!$this->retry) {
 $e = new TransportException('The "'.$this->fileUrl.'" file could not be downloaded ('.$http_response_header[0].')', $errorCode);
 $e->setHeaders($http_response_header);
 $e->setResponse($result);
 throw $e;
 }
 $result = false;
 }

 if ($this->progress && !$this->retry) {
 $this->io->overwriteError("    Downloading: <comment>100%</comment>");
 }


 if ($result && extension_loaded('zlib') && substr($fileUrl, 0, 4) === 'http') {
 $decode = false;
 foreach ($http_response_header as $header) {
 if (preg_match('{^content-encoding: *gzip *$}i', $header)) {
 $decode = true;
 } elseif (preg_match('{^HTTP/}i', $header)) {

 
 $decode = false;
 }
 }

 if ($decode) {
 try {
 if (PHP_VERSION_ID >= 50400) {
 $result = zlib_decode($result);
 } else {

 $result = file_get_contents('compress.zlib://data:application/octet-stream;base64,'.base64_encode($result));
 }

 if (!$result) {
 throw new TransportException('Failed to decode zlib stream');
 }
 } catch (\Exception $e) {
 if ($this->degradedMode) {
 throw $e;
 }

 $this->degradedMode = true;
 $this->io->writeError(array(
 '<error>Failed to decode response: '.$e->getMessage().'</error>',
 '<error>Retrying with degraded mode, check https://getcomposer.org/doc/articles/troubleshooting.md#degraded-mode for more info</error>'
 ));

 return $this->get($this->originUrl, $this->fileUrl, $additionalOptions, $this->fileName, $this->progress);
 }
 }
 }


 if (false !== $result && null !== $fileName) {
 if ('' === $result) {
 throw new TransportException('"'.$this->fileUrl.'" appears broken, and returned an empty 200 response');
 }

 $errorMessage = '';
 set_error_handler(function ($code, $msg) use (&$errorMessage) {
 if ($errorMessage) {
 $errorMessage .= "\n";
 }
 $errorMessage .= preg_replace('{^file_put_contents\(.*?\): }', '', $msg);
 });
 $result = (bool) file_put_contents($fileName, $result);
 restore_error_handler();
 if (false === $result) {
 throw new TransportException('The "'.$this->fileUrl.'" file could not be written to '.$fileName.': '.$errorMessage);
 }
 }

 if ($this->retry) {
 $this->retry = false;

 $result = $this->get($this->originUrl, $this->fileUrl, $additionalOptions, $this->fileName, $this->progress);

 $authHelper = new AuthHelper($this->io, $this->config);
 $authHelper->storeAuth($this->originUrl, $this->storeAuth);
 $this->storeAuth = false;

 return $result;
 }

 if (false === $result) {
 $e = new TransportException('The "'.$this->fileUrl.'" file could not be downloaded: '.$errorMessage, $errorCode);
 if (!empty($http_response_header[0])) {
 $e->setHeaders($http_response_header);
 }

 if (!$this->degradedMode && false !== strpos($e->getMessage(), 'Operation timed out')) {
 $this->degradedMode = true;
 $this->io->writeError(array(
 '<error>'.$e->getMessage().'</error>',
 '<error>Retrying with degraded mode, check https://getcomposer.org/doc/articles/troubleshooting.md#degraded-mode for more info</error>'
 ));

 return $this->get($this->originUrl, $this->fileUrl, $additionalOptions, $this->fileName, $this->progress);
 }

 throw $e;
 }

 if (!empty($http_response_header[0])) {
 $this->lastHeaders = $http_response_header;
 }

 return $result;
 }












 protected function callbackGet($notificationCode, $severity, $message, $messageCode, $bytesTransferred, $bytesMax)
 {
 switch ($notificationCode) {
 case STREAM_NOTIFY_FAILURE:
 case STREAM_NOTIFY_AUTH_REQUIRED:
 if (401 === $messageCode) {

 if (!$this->retryAuthFailure) {
 break;
 }

 $this->promptAuthAndRetry($messageCode);
 }
 break;

 case STREAM_NOTIFY_AUTH_RESULT:
 if (403 === $messageCode) {

 if (!$this->retryAuthFailure) {
 break;
 }

 $this->promptAuthAndRetry($messageCode, $message);
 }
 break;

 case STREAM_NOTIFY_FILE_SIZE_IS:
 if ($this->bytesMax < $bytesMax) {
 $this->bytesMax = $bytesMax;
 }
 break;

 case STREAM_NOTIFY_PROGRESS:
 if ($this->bytesMax > 0 && $this->progress) {
 $progression = round($bytesTransferred / $this->bytesMax * 100);

 if ((0 === $progression % 5) && 100 !== $progression && $progression !== $this->lastProgress) {
 $this->lastProgress = $progression;
 $this->io->overwriteError("    Downloading: <comment>$progression%</comment>", false);
 }
 }
 break;

 default:
 break;
 }
 }

 protected function promptAuthAndRetry($httpStatus, $reason = null)
 {
 if ($this->config && in_array($this->originUrl, $this->config->get('github-domains'), true)) {
 $message = "\n".'Could not fetch '.$this->fileUrl.', please create a GitHub OAuth token '.($httpStatus === 404 ? 'to access private repos' : 'to go over the API rate limit');
 $gitHubUtil = new GitHub($this->io, $this->config, null);
 if (!$gitHubUtil->authorizeOAuth($this->originUrl)
 && (!$this->io->isInteractive() || !$gitHubUtil->authorizeOAuthInteractively($this->originUrl, $message))
 ) {
 throw new TransportException('Could not authenticate against '.$this->originUrl, 401);
 }
 } else {

 if ($httpStatus === 404) {
 return;
 }


 if (!$this->io->isInteractive()) {
 if ($httpStatus === 401) {
 $message = "The '" . $this->fileUrl . "' URL required authentication.\nYou must be using the interactive console to authenticate";
 }
 if ($httpStatus === 403) {
 $message = "The '" . $this->fileUrl . "' URL could not be accessed: " . $reason;
 }

diff --git a/Santander_src_.htaccess b/Santander_src_.htaccess
diff --git a/Santander_src_Eesa_BridgeBundle_Bridge_CompanyBridge.php b/Santander_src_Eesa_BridgeBundle_Bridge_CompanyBridge.php
diff --git a/Santander_src_Eesa_BridgeBundle_Bridge_UserBridge.php b/Santander_src_Eesa_BridgeBundle_Bridge_UserBridge.php
diff --git a/Santander_src_Eesa_BridgeBundle_Command_ExportUserCommand.php b/Santander_src_Eesa_BridgeBundle_Command_ExportUserCommand.php
diff --git a/Santander_src_Eesa_BridgeBundle_Command_ImportCompanyCommand.php b/Santander_src_Eesa_BridgeBundle_Command_ImportCompanyCommand.php
diff --git a/Santander_src_Eesa_BridgeBundle_Command_ImportMissingCommand.php b/Santander_src_Eesa_BridgeBundle_Command_ImportMissingCommand.php
diff --git a/Santander_src_Eesa_BridgeBundle_Command_ImportUserCommand.php b/Santander_src_Eesa_BridgeBundle_Command_ImportUserCommand.php
diff --git a/Santander_src_Eesa_BridgeBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_BridgeBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_BridgeBundle_DependencyInjection_EesaBridgeExtension.php b/Santander_src_Eesa_BridgeBundle_DependencyInjection_EesaBridgeExtension.php
diff --git a/Santander_src_Eesa_BridgeBundle_EesaBridgeBundle.php b/Santander_src_Eesa_BridgeBundle_EesaBridgeBundle.php
diff --git a/Santander_src_Eesa_BridgeBundle_Entity_Company.php b/Santander_src_Eesa_BridgeBundle_Entity_Company.php
diff --git a/Santander_src_Eesa_BridgeBundle_Entity_Repository_UserRepository.php b/Santander_src_Eesa_BridgeBundle_Entity_Repository_UserRepository.php
diff --git a/Santander_src_Eesa_BridgeBundle_Entity_User.php b/Santander_src_Eesa_BridgeBundle_Entity_User.php
diff --git a/Santander_src_Eesa_BridgeBundle_EventListener_CompanyListener.php b/Santander_src_Eesa_BridgeBundle_EventListener_CompanyListener.php
diff --git a/Santander_src_Eesa_BridgeBundle_EventListener_UserListener.php b/Santander_src_Eesa_BridgeBundle_EventListener_UserListener.php
diff --git a/Santander_src_Eesa_BridgeBundle_Resources_config_services.yml b/Santander_src_Eesa_BridgeBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_CoreBundle_Controller_Controller.php b/Santander_src_Eesa_CoreBundle_Controller_Controller.php
diff --git a/Santander_src_Eesa_CoreBundle_Controller_CrudController.php b/Santander_src_Eesa_CoreBundle_Controller_CrudController.php
diff --git a/Santander_src_Eesa_CoreBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_CoreBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_CoreBundle_DependencyInjection_EesaCoreExtension.php b/Santander_src_Eesa_CoreBundle_DependencyInjection_EesaCoreExtension.php
diff --git a/Santander_src_Eesa_CoreBundle_EesaCoreBundle.php b/Santander_src_Eesa_CoreBundle_EesaCoreBundle.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_BaseEntity.php b/Santander_src_Eesa_CoreBundle_Entity_BaseEntity.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_Config.php b/Santander_src_Eesa_CoreBundle_Entity_Config.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_Extension_AddedAndOwnedTrait.php b/Santander_src_Eesa_CoreBundle_Entity_Extension_AddedAndOwnedTrait.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_Configurator_OwnedByConfigurator.php b/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_Configurator_OwnedByConfigurator.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_DeletedFilter.php b/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_DeletedFilter.php
diff --git a/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_OwnedByFilter.php b/Santander_src_Eesa_CoreBundle_Entity_Repository_Filter_OwnedByFilter.php
diff --git a/Santander_src_Eesa_CoreBundle_Handler_SessionHandler.php b/Santander_src_Eesa_CoreBundle_Handler_SessionHandler.php
diff --git a/Santander_src_Eesa_CoreBundle_Listener_AddedAndOwned.php b/Santander_src_Eesa_CoreBundle_Listener_AddedAndOwned.php
diff --git a/Santander_src_Eesa_CoreBundle_Manager_SlackManager.php b/Santander_src_Eesa_CoreBundle_Manager_SlackManager.php
diff --git a/Santander_src_Eesa_CoreBundle_Repository_TranslatableRepository.php b/Santander_src_Eesa_CoreBundle_Repository_TranslatableRepository.php
diff --git a/Santander_src_Eesa_CoreBundle_Resources_config_serializer_Entity.BaseEntity.yml b/Santander_src_Eesa_CoreBundle_Resources_config_serializer_Entity.BaseEntity.yml
diff --git a/Santander_src_Eesa_CoreBundle_Resources_config_services.yml b/Santander_src_Eesa_CoreBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_CoreBundle_Service_ConfigManager.php b/Santander_src_Eesa_CoreBundle_Service_ConfigManager.php
diff --git a/Santander_src_Eesa_CoreBundle_Service_MailManager.php b/Santander_src_Eesa_CoreBundle_Service_MailManager.php
diff --git a/Santander_src_Eesa_CoreBundle_Service_Tools.php b/Santander_src_Eesa_CoreBundle_Service_Tools.php
diff --git a/Santander_src_Eesa_CoreBundle_Service_Translation.php b/Santander_src_Eesa_CoreBundle_Service_Translation.php
diff --git a/Santander_src_Eesa_CoreBundle_SwiftMailer_MandrillTestTransport.php b/Santander_src_Eesa_CoreBundle_SwiftMailer_MandrillTestTransport.php
diff --git a/Santander_src_Eesa_CoreBundle_SwiftMailer_MandrillTransport.php b/Santander_src_Eesa_CoreBundle_SwiftMailer_MandrillTransport.php
diff --git a/Santander_src_Eesa_DataBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_DataBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_DataBundle_DependencyInjection_EesaDataExtension.php b/Santander_src_Eesa_DataBundle_DependencyInjection_EesaDataExtension.php
diff --git a/Santander_src_Eesa_DataBundle_EesaDataBundle.php b/Santander_src_Eesa_DataBundle_EesaDataBundle.php
diff --git a/Santander_src_Eesa_DataBundle_Entity_NomenclatureHS.php b/Santander_src_Eesa_DataBundle_Entity_NomenclatureHS.php
diff --git a/Santander_src_Eesa_DataBundle_Entity_NomenclatureService.php b/Santander_src_Eesa_DataBundle_Entity_NomenclatureService.php
diff --git a/Santander_src_Eesa_DataBundle_Entity_Repository_NomenclatureHSRepository.php b/Santander_src_Eesa_DataBundle_Entity_Repository_NomenclatureHSRepository.php
diff --git a/Santander_src_Eesa_DataBundle_Entity_Repository_NomenclatureServiceRepository.php b/Santander_src_Eesa_DataBundle_Entity_Repository_NomenclatureServiceRepository.php
diff --git a/Santander_src_Eesa_DataBundle_Resources_config_routing.yml b/Santander_src_Eesa_DataBundle_Resources_config_routing.yml
diff --git a/Santander_src_Eesa_DataBundle_Resources_config_services.yml b/Santander_src_Eesa_DataBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_DataBundle_Service_NomenclatureManager.php b/Santander_src_Eesa_DataBundle_Service_NomenclatureManager.php
diff --git a/Santander_src_Eesa_GeoBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_GeoBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_GeoBundle_DependencyInjection_EesaGeoExtension.php b/Santander_src_Eesa_GeoBundle_DependencyInjection_EesaGeoExtension.php
diff --git a/Santander_src_Eesa_GeoBundle_EesaGeoBundle.php b/Santander_src_Eesa_GeoBundle_EesaGeoBundle.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Address.php b/Santander_src_Eesa_GeoBundle_Entity_Address.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Country.php b/Santander_src_Eesa_GeoBundle_Entity_Country.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_AddressInterface.php b/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_AddressInterface.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_CountryInterface.php b/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_CountryInterface.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_LangInterface.php b/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_LangInterface.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_RegionInterface.php b/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_RegionInterface.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_TimezoneInterface.php b/Santander_src_Eesa_GeoBundle_Entity_EntityInterface_TimezoneInterface.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Lang.php b/Santander_src_Eesa_GeoBundle_Entity_Lang.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Region.php b/Santander_src_Eesa_GeoBundle_Entity_Region.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Repository_AddressRepository.php b/Santander_src_Eesa_GeoBundle_Entity_Repository_AddressRepository.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Repository_CountryRepository.php b/Santander_src_Eesa_GeoBundle_Entity_Repository_CountryRepository.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Repository_RegionRepository.php b/Santander_src_Eesa_GeoBundle_Entity_Repository_RegionRepository.php
diff --git a/Santander_src_Eesa_GeoBundle_Entity_Timezone.php b/Santander_src_Eesa_GeoBundle_Entity_Timezone.php
diff --git a/Santander_src_Eesa_GeoBundle_Manager_VatManager.php b/Santander_src_Eesa_GeoBundle_Manager_VatManager.php
diff --git a/Santander_src_Eesa_GeoBundle_Resources_config_services.yml b/Santander_src_Eesa_GeoBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_I18nRoutingBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_I18nRoutingBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_I18nRoutingBundle_DependencyInjection_EesaI18nRoutingExtension.php b/Santander_src_Eesa_I18nRoutingBundle_DependencyInjection_EesaI18nRoutingExtension.php
diff --git a/Santander_src_Eesa_I18nRoutingBundle_EesaI18nRoutingBundle.php b/Santander_src_Eesa_I18nRoutingBundle_EesaI18nRoutingBundle.php
diff --git a/Santander_src_Eesa_I18nRoutingBundle_Resources_config_services.xml b/Santander_src_Eesa_I18nRoutingBundle_Resources_config_services.xml
diff --git a/Santander_src_Eesa_I18nRoutingBundle_Router_I18nRouter.php b/Santander_src_Eesa_I18nRoutingBundle_Router_I18nRouter.php
diff --git a/Santander_src_Eesa_MediaBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_MediaBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_MediaBundle_DependencyInjection_EesaMediaExtension.php b/Santander_src_Eesa_MediaBundle_DependencyInjection_EesaMediaExtension.php
diff --git a/Santander_src_Eesa_MediaBundle_EesaMediaBundle.php b/Santander_src_Eesa_MediaBundle_EesaMediaBundle.php
diff --git a/Santander_src_Eesa_MediaBundle_Entity_File.php b/Santander_src_Eesa_MediaBundle_Entity_File.php
diff --git a/Santander_src_Eesa_MediaBundle_FileType_LocalFile.php b/Santander_src_Eesa_MediaBundle_FileType_LocalFile.php
diff --git a/Santander_src_Eesa_MediaBundle_Form_Extension_FileTypeExtension.php b/Santander_src_Eesa_MediaBundle_Form_Extension_FileTypeExtension.php
diff --git a/Santander_src_Eesa_MediaBundle_Form_FileType.php b/Santander_src_Eesa_MediaBundle_Form_FileType.php
diff --git a/Santander_src_Eesa_MediaBundle_Resources_config_services.yml b/Santander_src_Eesa_MediaBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_MediaBundle_Service_MediaManager.php b/Santander_src_Eesa_MediaBundle_Service_MediaManager.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_AdminUserNotificationController.php b/Santander_src_Eesa_SanAdminBundle_Controller_AdminUserNotificationController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_CompanyController.php b/Santander_src_Eesa_SanAdminBundle_Controller_CompanyController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_CountryController.php b/Santander_src_Eesa_SanAdminBundle_Controller_CountryController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_DashboardController.php b/Santander_src_Eesa_SanAdminBundle_Controller_DashboardController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_FusionController.php b/Santander_src_Eesa_SanAdminBundle_Controller_FusionController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_SecurityController.php b/Santander_src_Eesa_SanAdminBundle_Controller_SecurityController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_UserController.php b/Santander_src_Eesa_SanAdminBundle_Controller_UserController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarCategoryController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarCategoryController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarCountryController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarCountryController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarInvitationController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarInvitationController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarLangController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarLangController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarPromoterController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarPromoterController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarSpeakerController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarSpeakerController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Controller_WebinarTagController.php b/Santander_src_Eesa_SanAdminBundle_Controller_WebinarTagController.php
diff --git a/Santander_src_Eesa_SanAdminBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_SanAdminBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_SanAdminBundle_DependencyInjection_EesaSanAdminExtension.php b/Santander_src_Eesa_SanAdminBundle_DependencyInjection_EesaSanAdminExtension.php
diff --git a/Santander_src_Eesa_SanAdminBundle_EesaSanAdminBundle.php b/Santander_src_Eesa_SanAdminBundle_EesaSanAdminBundle.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Filter_AuthenticationLogFilterType.php b/Santander_src_Eesa_SanAdminBundle_Form_Filter_AuthenticationLogFilterType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Filter_AuthenticationLogUserFilterType.php b/Santander_src_Eesa_SanAdminBundle_Form_Filter_AuthenticationLogUserFilterType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Filter_CompanyFilterType.php b/Santander_src_Eesa_SanAdminBundle_Form_Filter_CompanyFilterType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Filter_UserFilterType.php b/Santander_src_Eesa_SanAdminBundle_Form_Filter_UserFilterType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Filter_UserProfileFilterType.php b/Santander_src_Eesa_SanAdminBundle_Form_Filter_UserProfileFilterType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Type_User_CompanyType.php b/Santander_src_Eesa_SanAdminBundle_Form_Type_User_CompanyType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Type_User_ProfileType.php b/Santander_src_Eesa_SanAdminBundle_Form_Type_User_ProfileType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserExpirationType.php b/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserExpirationType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserLevelType.php b/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserLevelType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserType.php b/Santander_src_Eesa_SanAdminBundle_Form_Type_User_UserType.php
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_company.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_company.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_config.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_config.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_country.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_country.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_user.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_user.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_webinar.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_routing_webinar.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_config_services.yml b/Santander_src_Eesa_SanAdminBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_AdminUserNotification_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_AdminUserNotification_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_base.empty.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_base.empty.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_baseModal.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_baseModal.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Company_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_disableOnSubmit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_disableOnSubmit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_nav.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_nav.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Crud_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Dashboard_dashboard.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Dashboard_dashboard.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Form_bootstrap_3_horizontal_layout_extended.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Form_bootstrap_3_horizontal_layout_extended.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Fusion_iframe.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Fusion_iframe.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Country_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Geo_Lang_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_layout.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_layout.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_nav.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_nav.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Security_login.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Security_login.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_authenticationList.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_authenticationList.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_delete.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_delete.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_expirationModal.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_expirationModal.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_import.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_import.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_importConfirmation.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_importConfirmation.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_invite.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_invite.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_levelModal.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_levelModal.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_list.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_list.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_nav.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_nav.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_renewal.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_renewal.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_User_upgrade.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_User_upgrade.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Category_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_InvitationList_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Promoter_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Speaker_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Tag_show.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_edit.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_edit.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_index.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_index.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_invitation.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_invitation.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_new.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_new.html.twig
diff --git a/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_show.html.twig b/Santander_src_Eesa_SanAdminBundle_Resources_views_Webinar_Webinar_show.html.twig
diff --git a/Santander_src_Eesa_SantanderBundle_Command_AdminNotificationCommand.php b/Santander_src_Eesa_SantanderBundle_Command_AdminNotificationCommand.php
diff --git a/Santander_src_Eesa_SantanderBundle_Command_ClientExpirationCommand.php b/Santander_src_Eesa_SantanderBundle_Command_ClientExpirationCommand.php
diff --git a/Santander_src_Eesa_SantanderBundle_Command_FreeTrialInvitationCommand.php b/Santander_src_Eesa_SantanderBundle_Command_FreeTrialInvitationCommand.php
diff --git a/Santander_src_Eesa_SantanderBundle_Command_InviteDisabledUsersCommand.php b/Santander_src_Eesa_SantanderBundle_Command_InviteDisabledUsersCommand.php
diff --git a/Santander_src_Eesa_SantanderBundle_Command_NavCommand.php b/Santander_src_Eesa_SantanderBundle_Command_NavCommand.php
diff --git a/Santander_src_Eesa_SantanderBundle_Controller_CompanyController.php b/Santander_src_Eesa_SantanderBundle_Controller_CompanyController.php
diff --git a/Santander_src_Eesa_SantanderBundle_Controller_ContextController.php b/Santander_src_Eesa_SantanderBundle_Controller_ContextController.php
diff --git a/Santander_src_Eesa_SantanderBundle_Controller_HubController.php b/Santander_src_Eesa_SantanderBundle_Controller_HubController.php
diff --git a/Santander_src_Eesa_SantanderBundle_Controller_UserController.php b/Santander_src_Eesa_SantanderBundle_Controller_UserController.php
diff --git a/Santander_src_Eesa_SantanderBundle_Controller_WebinarController.php b/Santander_src_Eesa_SantanderBundle_Controller_WebinarController.php
diff --git a/Santander_src_Eesa_SantanderBundle_DependencyInjection_Configuration.php b/Santander_src_Eesa_SantanderBundle_DependencyInjection_Configuration.php
diff --git a/Santander_src_Eesa_SantanderBundle_DependencyInjection_EesaSantanderExtension.php b/Santander_src_Eesa_SantanderBundle_DependencyInjection_EesaSantanderExtension.php
diff --git a/Santander_src_Eesa_SantanderBundle_EesaSantanderBundle.php b/Santander_src_Eesa_SantanderBundle_EesaSantanderBundle.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Address.php b/Santander_src_Eesa_SantanderBundle_Entity_Address.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_AuthenticationLog.php b/Santander_src_Eesa_SantanderBundle_Entity_AuthenticationLog.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Company.php b/Santander_src_Eesa_SantanderBundle_Entity_Company.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Country.php b/Santander_src_Eesa_SantanderBundle_Entity_Country.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_CountryTranslation.php b/Santander_src_Eesa_SantanderBundle_Entity_CountryTranslation.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Invitation.php b/Santander_src_Eesa_SantanderBundle_Entity_Invitation.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Lang.php b/Santander_src_Eesa_SantanderBundle_Entity_Lang.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_LangTranslation.php b/Santander_src_Eesa_SantanderBundle_Entity_LangTranslation.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Profile.php b/Santander_src_Eesa_SantanderBundle_Entity_Profile.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Region.php b/Santander_src_Eesa_SantanderBundle_Entity_Region.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_AddressRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_AddressRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_AuthenticationLogRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_AuthenticationLogRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_CompanyRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_CompanyRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_CountryRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_CountryRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_InvitationRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_InvitationRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_LangRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_LangRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_ProfileRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_ProfileRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_RegionRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_RegionRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_TimezoneRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_TimezoneRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Repository_UserRepository.php b/Santander_src_Eesa_SantanderBundle_Entity_Repository_UserRepository.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_Timezone.php b/Santander_src_Eesa_SantanderBundle_Entity_Timezone.php
diff --git a/Santander_src_Eesa_SantanderBundle_Entity_User.php b/Santander_src_Eesa_SantanderBundle_Entity_User.php
diff --git a/Santander_src_Eesa_SantanderBundle_Event_AuthenticationEvent.php b/Santander_src_Eesa_SantanderBundle_Event_AuthenticationEvent.php
diff --git a/Santander_src_Eesa_SantanderBundle_Event_LogoutEvent.php b/Santander_src_Eesa_SantanderBundle_Event_LogoutEvent.php
diff --git a/Santander_src_Eesa_SantanderBundle_EventListener_UserListener.php b/Santander_src_Eesa_SantanderBundle_EventListener_UserListener.php
diff --git a/Santander_src_Eesa_SantanderBundle_EventListener_UsernamePasswordFormAuthenticationListener.php b/Santander_src_Eesa_SantanderBundle_EventListener_UsernamePasswordFormAuthenticationListener.php
diff --git a/Santander_src_Eesa_SantanderBundle_Exception_AuthenticationTokenInvalidException.php b/Santander_src_Eesa_SantanderBundle_Exception_AuthenticationTokenInvalidException.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_DataTransformer_CompanyToIdTransformer.php b/Santander_src_Eesa_SantanderBundle_Form_DataTransformer_CompanyToIdTransformer.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_Geo_CountryType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_Geo_CountryType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_Geo_LangType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_Geo_LangType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_Hub_AssistanceType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_Hub_AssistanceType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_InviteUserType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_InviteUserType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_JoinProfileType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_JoinProfileType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_JoinType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_JoinType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_ProfileType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_ProfileType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_RegisterProfileType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_RegisterProfileType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_RegisterType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_RegisterType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_User_UserType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_User_UserType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_Webinar_RegisterProfileType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_Webinar_RegisterProfileType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Form_Type_Webinar_RegisterType.php b/Santander_src_Eesa_SantanderBundle_Form_Type_Webinar_RegisterType.php
diff --git a/Santander_src_Eesa_SantanderBundle_Handler_AuthenticationSuccessHandler.php b/Santander_src_Eesa_SantanderBundle_Handler_AuthenticationSuccessHandler.php
diff --git a/Santander_src_Eesa_SantanderBundle_Handler_LogoutSuccessHandler.php b/Santander_src_Eesa_SantanderBundle_Handler_LogoutSuccessHandler.php
diff --git a/Santander_src_Eesa_SantanderBundle_Manager_CompanyManager.php b/Santander_src_Eesa_SantanderBundle_Manager_CompanyManager.php
diff --git a/Santander_src_Eesa_SantanderBundle_Manager_CountryManager.php b/Santander_src_Eesa_SantanderBundle_Manager_CountryManager.php
diff --git a/Santander_src_Eesa_SantanderBundle_Manager_ProfileManager.php b/Santander_src_Eesa_SantanderBundle_Manager_ProfileManager.php
diff --git a/Santander_src_Eesa_SantanderBundle_Manager_UserManager.php b/Santander_src_Eesa_SantanderBundle_Manager_UserManager.php
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_routing.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_routing.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_routing_company.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_routing_company.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_routing_hub.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_routing_hub.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_routing_user.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_routing_user.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_routing_webinar.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_routing_webinar.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_serializer_Entity.Company.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_serializer_Entity.Company.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_config_services.yml b/Santander_src_Eesa_SantanderBundle_Resources_config_services.yml
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.en.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.en.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.es.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.es.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.pl.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.pl.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.pt.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_messages.pt.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.en.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.en.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.es.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.es.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.pl.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.pl.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.pt.csv b/Santander_src_Eesa_SantanderBundle_Resources_translations_routes.pt.csv
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_views_base.webinar.html.twig b/Santander_src_Eesa_SantanderBundle_Resources_views_base.webinar.html.twig
diff --git a/Santander_src_Eesa_SantanderBundle_Resources_views_Company_typeahead.html.twig b/Santander_src_Eesa_SantanderBundle_Resources_views_Company_typeahead.html.twig
	# Created by https://www.gitignore.io

	### PhpStorm ###
	# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm

	*.iml

	## Directory-based project format:
	.idea/

	## File-based project format:
	*.ipr
	*.iws

	## Plugin-specific files:

	# mpeltonen/sbt-idea plugin
	.idea_modules/


	### Symfony ###
	# Cache and logs (Symfony2)
	/app/cache/*
	/app/logs/*
	!app/cache/.gitkeep
	!app/logs/.gitkeep

	# Phing artifacts builded.
	/app/build/

	# Parameters
	/app/config/parameters.yml

	# Managed by Composer
	/app/bootstrap.php.cache
	/bin/*
	!bin/console
	!bin/symfony_requirements
	/vendor/

	# Assets and user uploads
	/web/bundles/
	/web/uploads/

	# PHPUnit
	/app/phpunit.xml
	/phpunit.xml

	# Build data
	/build/

	# Composer PHAR
	/composer.phar

	# Media
	/web/media

	.DS_Store
	*.php~
	/web/front/bower_components/*
	/web/front/node_modules/*

	# for translation system
	/app/Resources/translations
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="ProjectRootManager" version="2" />
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="ProjectModuleManager">
	<modules>
	<module fileurl="file://$PROJECT_DIR$/.idea/Santander.iml" filepath="$PROJECT_DIR$/.idea/Santander.iml" />
	</modules>
	</component>
	</project>
	<?xml version="1.0" encoding="UTF-8"?>
	<module type="WEB_MODULE" version="4">
	<component name="NewModuleRootManager">
	<content url="file://$MODULE_DIR$" />
	<orderEntry type="inheritedJdk" />
	<orderEntry type="sourceFolder" forTests="false" />
	<orderEntry type="module-library">
	<library name="PHARS">
	<CLASSES>
	<root url="phar://$MODULE_DIR$/composer.phar" />
	</CLASSES>
	<SOURCES>
	<root url="phar://$MODULE_DIR$/composer.phar" />
	</SOURCES>
	</library>
	</orderEntry>
	</component>
	</module>
	<component name="DependencyValidationManager">
	<state>
	<option name="SKIP_IMPORT_STATEMENTS" value="false" />
	</state>
	</component>
	<?xml version="1.0" encoding="UTF-8"?>
	<project version="4">
	<component name="VcsDirectoryMappings">
	<mapping directory="" vcs="" />
	</component>
	</project>
	<IfModule mod_authz_core.c>
	Require all denied
	</IfModule>
	<IfModule !mod_authz_core.c>
	Order deny,allow
	Deny from all
	</IfModule>
	<?php

	require_once __DIR__.'/AppKernel.php';

	use Symfony\Bundle\FrameworkBundle\HttpCache\HttpCache;

	class AppCache extends HttpCache
	{
	}
	<?php

	use Symfony\Component\HttpKernel\Kernel;
	use Symfony\Component\Config\Loader\LoaderInterface;

	class AppKernel extends Kernel
	{
	public function registerBundles()
	{
	$bundles = array(
	new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
	new Symfony\Bundle\SecurityBundle\SecurityBundle(),
	new Symfony\Bundle\TwigBundle\TwigBundle(),
	new Symfony\Bundle\MonologBundle\MonologBundle(),
	new Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),
	new Symfony\Bundle\AsseticBundle\AsseticBundle(),
	new Doctrine\Bundle\DoctrineBundle\DoctrineBundle(),
	new Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle(),

	new JMS\AopBundle\JMSAopBundle(),
	new JMS\SecurityExtraBundle\JMSSecurityExtraBundle(),
	new JMS\DiExtraBundle\JMSDiExtraBundle($this),
	new JMS\SerializerBundle\JMSSerializerBundle(),
	new FOS\UserBundle\FOSUserBundle(),
	new Lexik\Bundle\FormFilterBundle\LexikFormFilterBundle(),
	new Liip\ImagineBundle\LiipImagineBundle(),
	new JMS\I18nRoutingBundle\JMSI18nRoutingBundle(),
	new JMS\TranslationBundle\JMSTranslationBundle(),
	new Knp\Bundle\PaginatorBundle\KnpPaginatorBundle(),
	new A2lix\TranslationFormBundle\A2lixTranslationFormBundle(),
	new Genemu\Bundle\FormBundle\GenemuFormBundle(),
	new Accord\MandrillSwiftMailerBundle\AccordMandrillSwiftMailerBundle(),
	new Liuggio\ExcelBundle\LiuggioExcelBundle(),

	new Eesa\CoreBundle\EesaCoreBundle(),
	new Eesa\UserBundle\EesaUserBundle(),
	new Eesa\MediaBundle\EesaMediaBundle(),
	new Eesa\GeoBundle\EesaGeoBundle(),
	new Eesa\WebinarBundle\EesaWebinarBundle(),
	new Eesa\SantanderBundle\EesaSantanderBundle(),
	new Eesa\SanAdminBundle\EesaSanAdminBundle(),
	new Eesa\BridgeBundle\EesaBridgeBundle(),
	new Eesa\I18nRoutingBundle\EesaI18nRoutingBundle(),
	new Eesa\DataBundle\EesaDataBundle(),
	);

	if (in_array($this->getEnvironment(), array('dev', 'test'))) {
	$bundles[] = new Symfony\Bundle\DebugBundle\DebugBundle();
	$bundles[] = new Symfony\Bundle\WebProfilerBundle\WebProfilerBundle();
	$bundles[] = new Sensio\Bundle\DistributionBundle\SensioDistributionBundle();
	$bundles[] = new Sensio\Bundle\GeneratorBundle\SensioGeneratorBundle();
	}

	if (in_array($this->getEnvironment(), array('prod'))) {
	$bundles[] = new Evolution7\BugsnagBundle\BugsnagBundle();
	}

	return $bundles;
	}

	public function registerContainerConfiguration(LoaderInterface $loader)
	{
	$loader->load($this->getRootDir().'/config/config_'.$this->getEnvironment().'.yml');

	$envParamaters = $this->getEnvParameters();
	if (empty($envParamaters['fulldomain'])) {
	$loader->load($this->getRootDir().'/config/i18n.yml');
	}
	}
	}