Редакция 69 | Только различия | Не учитывать пробелы | Содержимое файла | Авторство | Последнее изменение | Открыть журнал | RSS
Редакция 69 | Редакция 87 | ||
---|---|---|---|
1 | <?php
|
1 | <?php
|
2 | /**
|
2 | /**
|
3 | * PEAR_Downloader_Package
|
3 | * PEAR_Downloader_Package
|
4 | *
|
4 | *
|
5 | * PHP versions 4 and 5
|
5 | * PHP versions 4 and 5
|
6 | *
|
6 | *
|
7 | * LICENSE: This source file is subject to version 3.0 of the PHP license
|
7 | * LICENSE: This source file is subject to version 3.0 of the PHP license
|
8 | * that is available through the world-wide-web at the following URI:
|
8 | * that is available through the world-wide-web at the following URI:
|
9 | * http://www.php.net/license/3_0.txt. If you did not receive a copy of
|
9 | * http://www.php.net/license/3_0.txt. If you did not receive a copy of
|
10 | * the PHP License and are unable to obtain it through the web, please
|
10 | * the PHP License and are unable to obtain it through the web, please
|
11 | * send a note to license@php.net so we can mail you a copy immediately.
|
11 | * send a note to license@php.net so we can mail you a copy immediately.
|
12 | *
|
12 | *
|
13 | * @category pear
|
13 | * @category pear
|
14 | * @package PEAR
|
14 | * @package PEAR
|
15 | * @author Greg Beaver <cellog@php.net>
|
15 | * @author Greg Beaver <cellog@php.net>
|
16 | * @copyright 1997-2008 The PHP Group
|
16 | * @copyright 1997-2008 The PHP Group
|
17 | * @license http://www.php.net/license/3_0.txt PHP License 3.0
|
17 | * @license http://www.php.net/license/3_0.txt PHP License 3.0
|
18 | * @version CVS: $Id: Package.php,v 1.113 2008/03/29 14:18:36 dufuz Exp $
|
18 | * @version CVS: $Id: Package.php,v 1.113 2008/03/29 14:18:36 dufuz Exp $
|
19 | * @link http://pear.php.net/package/PEAR
|
19 | * @link http://pear.php.net/package/PEAR
|
20 | * @since File available since Release 1.4.0a1
|
20 | * @since File available since Release 1.4.0a1
|
21 | */
|
21 | */
|
22 | /**
|
22 | /**
|
23 | * Error code when parameter initialization fails because no releases
|
23 | * Error code when parameter initialization fails because no releases
|
24 | * exist within preferred_state, but releases do exist
|
24 | * exist within preferred_state, but releases do exist
|
25 | */
|
25 | */
|
26 | define('PEAR_DOWNLOADER_PACKAGE_STATE', -1003); |
26 | define('PEAR_DOWNLOADER_PACKAGE_STATE', -1003); |
27 | /**
|
27 | /**
|
28 | * Error code when parameter initialization fails because no releases
|
28 | * Error code when parameter initialization fails because no releases
|
29 | * exist that will work with the existing PHP version
|
29 | * exist that will work with the existing PHP version
|
30 | */
|
30 | */
|
31 | define('PEAR_DOWNLOADER_PACKAGE_PHPVERSION', -1004); |
31 | define('PEAR_DOWNLOADER_PACKAGE_PHPVERSION', -1004); |
32 | /**
|
32 | /**
|
33 | * Coordinates download parameters and manages their dependencies
|
33 | * Coordinates download parameters and manages their dependencies
|
34 | * prior to downloading them.
|
34 | * prior to downloading them.
|
35 | *
|
35 | *
|
36 | * Input can come from three sources:
|
36 | * Input can come from three sources:
|
37 | *
|
37 | *
|
38 | * - local files (archives or package.xml)
|
38 | * - local files (archives or package.xml)
|
39 | * - remote files (downloadable urls)
|
39 | * - remote files (downloadable urls)
|
40 | * - abstract package names
|
40 | * - abstract package names
|
41 | *
|
41 | *
|
42 | * The first two elements are handled cleanly by PEAR_PackageFile, but the third requires
|
42 | * The first two elements are handled cleanly by PEAR_PackageFile, but the third requires
|
43 | * accessing pearweb's xml-rpc interface to determine necessary dependencies, and the
|
43 | * accessing pearweb's xml-rpc interface to determine necessary dependencies, and the
|
44 | * format returned of dependencies is slightly different from that used in package.xml.
|
44 | * format returned of dependencies is slightly different from that used in package.xml.
|
45 | *
|
45 | *
|
46 | * This class hides the differences between these elements, and makes automatic
|
46 | * This class hides the differences between these elements, and makes automatic
|
47 | * dependency resolution a piece of cake. It also manages conflicts when
|
47 | * dependency resolution a piece of cake. It also manages conflicts when
|
48 | * two classes depend on incompatible dependencies, or differing versions of the same
|
48 | * two classes depend on incompatible dependencies, or differing versions of the same
|
49 | * package dependency. In addition, download will not be attempted if the php version is
|
49 | * package dependency. In addition, download will not be attempted if the php version is
|
50 | * not supported, PEAR installer version is not supported, or non-PECL extensions are not
|
50 | * not supported, PEAR installer version is not supported, or non-PECL extensions are not
|
51 | * installed.
|
51 | * installed.
|
52 | * @category pear
|
52 | * @category pear
|
53 | * @package PEAR
|
53 | * @package PEAR
|
54 | * @author Greg Beaver <cellog@php.net>
|
54 | * @author Greg Beaver <cellog@php.net>
|
55 | * @copyright 1997-2008 The PHP Group
|
55 | * @copyright 1997-2008 The PHP Group
|
56 | * @license http://www.php.net/license/3_0.txt PHP License 3.0
|
56 | * @license http://www.php.net/license/3_0.txt PHP License 3.0
|
57 | * @version Release: 1.7.2
|
57 | * @version Release: 1.7.2
|
58 | * @link http://pear.php.net/package/PEAR
|
58 | * @link http://pear.php.net/package/PEAR
|
59 | * @since Class available since Release 1.4.0a1
|
59 | * @since Class available since Release 1.4.0a1
|
60 | */
|
60 | */
|
61 | class PEAR_Downloader_Package
|
61 | class PEAR_Downloader_Package
|
62 | {
|
62 | {
|
63 | /**
|
63 | /**
|
64 | * @var PEAR_Downloader
|
64 | * @var PEAR_Downloader
|
65 | */
|
65 | */
|
66 | var $_downloader; |
66 | var $_downloader; |
67 | /**
|
67 | /**
|
68 | * @var PEAR_Config
|
68 | * @var PEAR_Config
|
69 | */
|
69 | */
|
70 | var $_config; |
70 | var $_config; |
71 | /**
|
71 | /**
|
72 | * @var PEAR_Registry
|
72 | * @var PEAR_Registry
|
73 | */
|
73 | */
|
74 | var $_registry; |
74 | var $_registry; |
75 | /**
|
75 | /**
|
76 | * Used to implement packagingroot properly
|
76 | * Used to implement packagingroot properly
|
77 | * @var PEAR_Registry
|
77 | * @var PEAR_Registry
|
78 | */
|
78 | */
|
79 | var $_installRegistry; |
79 | var $_installRegistry; |
80 | /**
|
80 | /**
|
81 | * @var PEAR_PackageFile_v1|PEAR_PackageFile|v2
|
81 | * @var PEAR_PackageFile_v1|PEAR_PackageFile|v2
|
82 | */
|
82 | */
|
83 | var $_packagefile; |
83 | var $_packagefile; |
84 | /**
|
84 | /**
|
85 | * @var array
|
85 | * @var array
|
86 | */
|
86 | */
|
87 | var $_parsedname; |
87 | var $_parsedname; |
88 | /**
|
88 | /**
|
89 | * @var array
|
89 | * @var array
|
90 | */
|
90 | */
|
91 | var $_downloadURL; |
91 | var $_downloadURL; |
92 | /**
|
92 | /**
|
93 | * @var array
|
93 | * @var array
|
94 | */
|
94 | */
|
95 | var $_downloadDeps = array(); |
95 | var $_downloadDeps = array(); |
96 | /**
|
96 | /**
|
97 | * @var boolean
|
97 | * @var boolean
|
98 | */
|
98 | */
|
99 | var $_valid = false; |
99 | var $_valid = false; |
100 | /**
|
100 | /**
|
101 | * @var boolean
|
101 | * @var boolean
|
102 | */
|
102 | */
|
103 | var $_analyzed = false; |
103 | var $_analyzed = false; |
104 | /**
|
104 | /**
|
105 | * if this or a parent package was invoked with Package-state, this is set to the
|
105 | * if this or a parent package was invoked with Package-state, this is set to the
|
106 | * state variable.
|
106 | * state variable.
|
107 | *
|
107 | *
|
108 | * This allows temporary reassignment of preferred_state for a parent package and all of
|
108 | * This allows temporary reassignment of preferred_state for a parent package and all of
|
109 | * its dependencies.
|
109 | * its dependencies.
|
110 | * @var string|false
|
110 | * @var string|false
|
111 | */
|
111 | */
|
112 | var $_explicitState = false; |
112 | var $_explicitState = false; |
113 | /**
|
113 | /**
|
114 | * If this package is invoked with Package#group, this variable will be true
|
114 | * If this package is invoked with Package#group, this variable will be true
|
115 | */
|
115 | */
|
116 | var $_explicitGroup = false; |
116 | var $_explicitGroup = false; |
117 | /**
|
117 | /**
|
118 | * Package type local|url|xmlrpc
|
118 | * Package type local|url|xmlrpc
|
119 | * @var string
|
119 | * @var string
|
120 | */
|
120 | */
|
121 | var $_type; |
121 | var $_type; |
122 | /**
|
122 | /**
|
123 | * Contents of package.xml, if downloaded from a remote channel
|
123 | * Contents of package.xml, if downloaded from a remote channel
|
124 | * @var string|false
|
124 | * @var string|false
|
125 | * @access private
|
125 | * @access private
|
126 | */
|
126 | */
|
127 | var $_rawpackagefile; |
127 | var $_rawpackagefile; |
128 | /**
|
128 | /**
|
129 | * @var boolean
|
129 | * @var boolean
|
130 | * @access private
|
130 | * @access private
|
131 | */
|
131 | */
|
132 | var $_validated = false; |
132 | var $_validated = false; |
133 | 133 | ||
134 | /**
|
134 | /**
|
135 | * @param PEAR_Downloader
|
135 | * @param PEAR_Downloader
|
136 | */
|
136 | */
|
137 | function PEAR_Downloader_Package(&$downloader) |
137 | function PEAR_Downloader_Package(&$downloader) |
138 | {
|
138 | {
|
139 | $this->_downloader = &$downloader; |
139 | $this->_downloader = &$downloader; |
140 | $this->_config = &$this->_downloader->config; |
140 | $this->_config = &$this->_downloader->config; |
141 | $this->_registry = &$this->_config->getRegistry(); |
141 | $this->_registry = &$this->_config->getRegistry(); |
142 | $options = $downloader->getOptions(); |
142 | $options = $downloader->getOptions(); |
143 | if (isset($options['packagingroot'])) { |
143 | if (isset($options['packagingroot'])) { |
144 | $this->_config->setInstallRoot($options['packagingroot']); |
144 | $this->_config->setInstallRoot($options['packagingroot']); |
145 | $this->_installRegistry = &$this->_config->getRegistry(); |
145 | $this->_installRegistry = &$this->_config->getRegistry(); |
146 | $this->_config->setInstallRoot(false); |
146 | $this->_config->setInstallRoot(false); |
147 | } else { |
147 | } else { |
148 | $this->_installRegistry = &$this->_registry; |
148 | $this->_installRegistry = &$this->_registry; |
149 | }
|
149 | }
|
150 | $this->_valid = $this->_analyzed = false; |
150 | $this->_valid = $this->_analyzed = false; |
151 | }
|
151 | }
|
152 | 152 | ||
153 | /**
|
153 | /**
|
154 | * Parse the input and determine whether this is a local file, a remote uri, or an
|
154 | * Parse the input and determine whether this is a local file, a remote uri, or an
|
155 | * abstract package name.
|
155 | * abstract package name.
|
156 | *
|
156 | *
|
157 | * This is the heart of the PEAR_Downloader_Package(), and is used in
|
157 | * This is the heart of the PEAR_Downloader_Package(), and is used in
|
158 | * {@link PEAR_Downloader::download()}
|
158 | * {@link PEAR_Downloader::download()}
|
159 | * @param string
|
159 | * @param string
|
160 | * @return bool|PEAR_Error
|
160 | * @return bool|PEAR_Error
|
161 | */
|
161 | */
|
162 | function initialize($param) |
162 | function initialize($param) |
163 | {
|
163 | {
|
164 | $origErr = $this->_fromFile($param); |
164 | $origErr = $this->_fromFile($param); |
165 | if (!$this->_valid) { |
165 | if (!$this->_valid) { |
166 | $options = $this->_downloader->getOptions(); |
166 | $options = $this->_downloader->getOptions(); |
167 | if (isset($options['offline'])) { |
167 | if (isset($options['offline'])) { |
168 | if (PEAR::isError($origErr)) { |
168 | if (PEAR::isError($origErr)) { |
169 | if (!isset($options['soft'])) { |
169 | if (!isset($options['soft'])) { |
170 | $this->_downloader->log(0, $origErr->getMessage()); |
170 | $this->_downloader->log(0, $origErr->getMessage()); |
171 | }
|
171 | }
|
172 | }
|
172 | }
|
173 | return PEAR::raiseError('Cannot download non-local package "' . $param . '"'); |
173 | return PEAR::raiseError('Cannot download non-local package "' . $param . '"'); |
174 | }
|
174 | }
|
175 | $err = $this->_fromUrl($param); |
175 | $err = $this->_fromUrl($param); |
176 | if (PEAR::isError($err) || !$this->_valid) { |
176 | if (PEAR::isError($err) || !$this->_valid) { |
177 | if ($this->_type == 'url') { |
177 | if ($this->_type == 'url') { |
178 | if (PEAR::isError($err)) { |
178 | if (PEAR::isError($err)) { |
179 | if (!isset($options['soft'])) { |
179 | if (!isset($options['soft'])) { |
180 | $this->_downloader->log(0, $err->getMessage()); |
180 | $this->_downloader->log(0, $err->getMessage()); |
181 | }
|
181 | }
|
182 | }
|
182 | }
|
183 | return PEAR::raiseError("Invalid or missing remote package file"); |
183 | return PEAR::raiseError("Invalid or missing remote package file"); |
184 | }
|
184 | }
|
185 | $err = $this->_fromString($param); |
185 | $err = $this->_fromString($param); |
186 | if (PEAR::isError($err) || !$this->_valid) { |
186 | if (PEAR::isError($err) || !$this->_valid) { |
187 | if (PEAR::isError($err) && |
187 | if (PEAR::isError($err) && |
188 | $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) { |
188 | $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) { |
189 | return false; // instruct the downloader to silently skip |
189 | return false; // instruct the downloader to silently skip |
190 | }
|
190 | }
|
191 | if (isset($this->_type) && $this->_type == 'local' && |
191 | if (isset($this->_type) && $this->_type == 'local' && |
192 | PEAR::isError($origErr)) { |
192 | PEAR::isError($origErr)) { |
193 | if (is_array($origErr->getUserInfo())) { |
193 | if (is_array($origErr->getUserInfo())) { |
194 | foreach ($origErr->getUserInfo() as $err) { |
194 | foreach ($origErr->getUserInfo() as $err) { |
195 | if (is_array($err)) { |
195 | if (is_array($err)) { |
196 | $err = $err['message']; |
196 | $err = $err['message']; |
197 | }
|
197 | }
|
198 | if (!isset($options['soft'])) { |
198 | if (!isset($options['soft'])) { |
199 | $this->_downloader->log(0, $err); |
199 | $this->_downloader->log(0, $err); |
200 | }
|
200 | }
|
201 | }
|
201 | }
|
202 | }
|
202 | }
|
203 | if (!isset($options['soft'])) { |
203 | if (!isset($options['soft'])) { |
204 | $this->_downloader->log(0, $origErr->getMessage()); |
204 | $this->_downloader->log(0, $origErr->getMessage()); |
205 | }
|
205 | }
|
206 | if (is_array($param)) { |
206 | if (is_array($param)) { |
207 | $param = $this->_registry->parsedPackageNameToString($param, |
207 | $param = $this->_registry->parsedPackageNameToString($param, |
208 | true); |
208 | true); |
209 | }
|
209 | }
|
210 | return PEAR::raiseError( |
210 | return PEAR::raiseError( |
211 | "Cannot initialize '$param', invalid or missing package file"); |
211 | "Cannot initialize '$param', invalid or missing package file"); |
212 | }
|
212 | }
|
213 | if (PEAR::isError($err)) { |
213 | if (PEAR::isError($err)) { |
214 | if (!isset($options['soft'])) { |
214 | if (!isset($options['soft'])) { |
215 | $this->_downloader->log(0, $err->getMessage()); |
215 | $this->_downloader->log(0, $err->getMessage()); |
216 | }
|
216 | }
|
217 | }
|
217 | }
|
218 | if (is_array($param)) { |
218 | if (is_array($param)) { |
219 | $param = $this->_registry->parsedPackageNameToString($param, true); |
219 | $param = $this->_registry->parsedPackageNameToString($param, true); |
220 | }
|
220 | }
|
221 | return PEAR::raiseError( |
221 | return PEAR::raiseError( |
222 | "Cannot initialize '$param', invalid or missing package file"); |
222 | "Cannot initialize '$param', invalid or missing package file"); |
223 | }
|
223 | }
|
224 | }
|
224 | }
|
225 | }
|
225 | }
|
226 | return true; |
226 | return true; |
227 | }
|
227 | }
|
228 | 228 | ||
229 | /**
|
229 | /**
|
230 | * Retrieve any non-local packages
|
230 | * Retrieve any non-local packages
|
231 | * @return PEAR_PackageFile_v1|PEAR_PackageFile_v2|PEAR_Error
|
231 | * @return PEAR_PackageFile_v1|PEAR_PackageFile_v2|PEAR_Error
|
232 | */
|
232 | */
|
233 | function &download() |
233 | function &download() |
234 | {
|
234 | {
|
235 | if (isset($this->_packagefile)) { |
235 | if (isset($this->_packagefile)) { |
236 | return $this->_packagefile; |
236 | return $this->_packagefile; |
237 | }
|
237 | }
|
238 | if (isset($this->_downloadURL['url'])) { |
238 | if (isset($this->_downloadURL['url'])) { |
239 | $this->_isvalid = false; |
239 | $this->_isvalid = false; |
240 | $info = $this->getParsedPackage(); |
240 | $info = $this->getParsedPackage(); |
241 | foreach ($info as $i => $p) { |
241 | foreach ($info as $i => $p) { |
242 | $info[$i] = strtolower($p); |
242 | $info[$i] = strtolower($p); |
243 | }
|
243 | }
|
244 | $err = $this->_fromUrl($this->_downloadURL['url'], |
244 | $err = $this->_fromUrl($this->_downloadURL['url'], |
245 | $this->_registry->parsedPackageNameToString($this->_parsedname, true)); |
245 | $this->_registry->parsedPackageNameToString($this->_parsedname, true)); |
246 | $newinfo = $this->getParsedPackage(); |
246 | $newinfo = $this->getParsedPackage(); |
247 | foreach ($newinfo as $i => $p) { |
247 | foreach ($newinfo as $i => $p) { |
248 | $newinfo[$i] = strtolower($p); |
248 | $newinfo[$i] = strtolower($p); |
249 | }
|
249 | }
|
250 | if ($info != $newinfo) { |
250 | if ($info != $newinfo) { |
251 | do { |
251 | do { |
252 | if ($info['package'] == 'pecl.php.net' && $newinfo['package'] == 'pear.php.net') { |
252 | if ($info['package'] == 'pecl.php.net' && $newinfo['package'] == 'pear.php.net') { |
253 | $info['package'] = 'pear.php.net'; |
253 | $info['package'] = 'pear.php.net'; |
254 | if ($info == $newinfo) { |
254 | if ($info == $newinfo) { |
255 | // skip the channel check if a pecl package says it's a PEAR package
|
255 | // skip the channel check if a pecl package says it's a PEAR package
|
256 | break; |
256 | break; |
257 | }
|
257 | }
|
258 | }
|
258 | }
|
259 | return PEAR::raiseError('CRITICAL ERROR: We are ' . |
259 | return PEAR::raiseError('CRITICAL ERROR: We are ' . |
260 | $this->_registry->parsedPackageNameToString($info) . ', but the file ' . |
260 | $this->_registry->parsedPackageNameToString($info) . ', but the file ' . |
261 | 'downloaded claims to be ' . |
261 | 'downloaded claims to be ' . |
262 | $this->_registry->parsedPackageNameToString($this->getParsedPackage())); |
262 | $this->_registry->parsedPackageNameToString($this->getParsedPackage())); |
263 | } while (false); |
263 | } while (false); |
264 | }
|
264 | }
|
265 | if (PEAR::isError($err) || !$this->_valid) { |
265 | if (PEAR::isError($err) || !$this->_valid) { |
266 | return $err; |
266 | return $err; |
267 | }
|
267 | }
|
268 | }
|
268 | }
|
269 | $this->_type = 'local'; |
269 | $this->_type = 'local'; |
270 | return $this->_packagefile; |
270 | return $this->_packagefile; |
271 | }
|
271 | }
|
272 | 272 | ||
273 | function &getPackageFile() |
273 | function &getPackageFile() |
274 | {
|
274 | {
|
275 | return $this->_packagefile; |
275 | return $this->_packagefile; |
276 | }
|
276 | }
|
277 | 277 | ||
278 | function &getDownloader() |
278 | function &getDownloader() |
279 | {
|
279 | {
|
280 | return $this->_downloader; |
280 | return $this->_downloader; |
281 | }
|
281 | }
|
282 | 282 | ||
283 | function getType() |
283 | function getType() |
284 | {
|
284 | {
|
285 | return $this->_type; |
285 | return $this->_type; |
286 | }
|
286 | }
|
287 | 287 | ||
288 | /**
|
288 | /**
|
289 | * Like {@link initialize()}, but operates on a dependency
|
289 | * Like {@link initialize()}, but operates on a dependency
|
290 | */
|
290 | */
|
291 | function fromDepURL($dep) |
291 | function fromDepURL($dep) |
292 | {
|
292 | {
|
293 | $this->_downloadURL = $dep; |
293 | $this->_downloadURL = $dep; |
294 | if (isset($dep['uri'])) { |
294 | if (isset($dep['uri'])) { |
295 | $options = $this->_downloader->getOptions(); |
295 | $options = $this->_downloader->getOptions(); |
296 | if (!extension_loaded("zlib") || isset($options['nocompress'])) { |
296 | if (!extension_loaded("zlib") || isset($options['nocompress'])) { |
297 | $ext = '.tar'; |
297 | $ext = '.tar'; |
298 | } else { |
298 | } else { |
299 | $ext = '.tgz'; |
299 | $ext = '.tgz'; |
300 | }
|
300 | }
|
301 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
301 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
302 | $err = $this->_fromUrl($dep['uri'] . $ext); |
302 | $err = $this->_fromUrl($dep['uri'] . $ext); |
303 | PEAR::popErrorHandling(); |
303 | PEAR::popErrorHandling(); |
304 | if (PEAR::isError($err)) { |
304 | if (PEAR::isError($err)) { |
305 | if (!isset($options['soft'])) { |
305 | if (!isset($options['soft'])) { |
306 | $this->_downloader->log(0, $err->getMessage()); |
306 | $this->_downloader->log(0, $err->getMessage()); |
307 | }
|
307 | }
|
308 | return PEAR::raiseError('Invalid uri dependency "' . $dep['uri'] . $ext . '", ' . |
308 | return PEAR::raiseError('Invalid uri dependency "' . $dep['uri'] . $ext . '", ' . |
309 | 'cannot download'); |
309 | 'cannot download'); |
310 | }
|
310 | }
|
311 | } else { |
311 | } else { |
312 | $this->_parsedname = |
312 | $this->_parsedname = |
313 | array( |
313 | array( |
314 | 'package' => $dep['info']->getPackage(), |
314 | 'package' => $dep['info']->getPackage(), |
315 | 'channel' => $dep['info']->getChannel(), |
315 | 'channel' => $dep['info']->getChannel(), |
316 | 'version' => $dep['version'] |
316 | 'version' => $dep['version'] |
317 | ); |
317 | ); |
318 | if (!isset($dep['nodefault'])) { |
318 | if (!isset($dep['nodefault'])) { |
319 | $this->_parsedname['group'] = 'default'; // download the default dependency group |
319 | $this->_parsedname['group'] = 'default'; // download the default dependency group |
320 | $this->_explicitGroup = false; |
320 | $this->_explicitGroup = false; |
321 | }
|
321 | }
|
322 | $this->_rawpackagefile = $dep['raw']; |
322 | $this->_rawpackagefile = $dep['raw']; |
323 | }
|
323 | }
|
324 | }
|
324 | }
|
325 | 325 | ||
326 | function detectDependencies($params) |
326 | function detectDependencies($params) |
327 | {
|
327 | {
|
328 | $options = $this->_downloader->getOptions(); |
328 | $options = $this->_downloader->getOptions(); |
329 | if (isset($options['downloadonly'])) { |
329 | if (isset($options['downloadonly'])) { |
330 | return; |
330 | return; |
331 | }
|
331 | }
|
332 | if (isset($options['offline'])) { |
332 | if (isset($options['offline'])) { |
333 | $this->_downloader->log(3, 'Skipping dependency download check, --offline specified'); |
333 | $this->_downloader->log(3, 'Skipping dependency download check, --offline specified'); |
334 | return; |
334 | return; |
335 | }
|
335 | }
|
336 | $pname = $this->getParsedPackage(); |
336 | $pname = $this->getParsedPackage(); |
337 | if (!$pname) { |
337 | if (!$pname) { |
338 | return; |
338 | return; |
339 | }
|
339 | }
|
340 | $deps = $this->getDeps(); |
340 | $deps = $this->getDeps(); |
341 | if (!$deps) { |
341 | if (!$deps) { |
342 | return; |
342 | return; |
343 | }
|
343 | }
|
344 | if (isset($deps['required'])) { // package.xml 2.0 |
344 | if (isset($deps['required'])) { // package.xml 2.0 |
345 | return $this->_detect2($deps, $pname, $options, $params); |
345 | return $this->_detect2($deps, $pname, $options, $params); |
346 | } else { |
346 | } else { |
347 | return $this->_detect1($deps, $pname, $options, $params); |
347 | return $this->_detect1($deps, $pname, $options, $params); |
348 | }
|
348 | }
|
349 | }
|
349 | }
|
350 | 350 | ||
351 | function setValidated() |
351 | function setValidated() |
352 | {
|
352 | {
|
353 | $this->_validated = true; |
353 | $this->_validated = true; |
354 | }
|
354 | }
|
355 | 355 | ||
356 | function alreadyValidated() |
356 | function alreadyValidated() |
357 | {
|
357 | {
|
358 | return $this->_validated; |
358 | return $this->_validated; |
359 | }
|
359 | }
|
360 | 360 | ||
361 | /**
|
361 | /**
|
362 | * Remove packages to be downloaded that are already installed
|
362 | * Remove packages to be downloaded that are already installed
|
363 | * @param array of PEAR_Downloader_Package objects
|
363 | * @param array of PEAR_Downloader_Package objects
|
364 | * @static
|
364 | * @static
|
365 | */
|
365 | */
|
366 | function removeInstalled(&$params) |
366 | function removeInstalled(&$params) |
367 | {
|
367 | {
|
368 | if (!isset($params[0])) { |
368 | if (!isset($params[0])) { |
369 | return; |
369 | return; |
370 | }
|
370 | }
|
371 | $options = $params[0]->_downloader->getOptions(); |
371 | $options = $params[0]->_downloader->getOptions(); |
372 | if (!isset($options['downloadonly'])) { |
372 | if (!isset($options['downloadonly'])) { |
373 | foreach ($params as $i => $param) { |
373 | foreach ($params as $i => $param) { |
374 | // remove self if already installed with this version
|
374 | // remove self if already installed with this version
|
375 | // this does not need any pecl magic - we only remove exact matches
|
375 | // this does not need any pecl magic - we only remove exact matches
|
376 | if ($param->_installRegistry->packageExists($param->getPackage(), $param->getChannel())) { |
376 | if ($param->_installRegistry->packageExists($param->getPackage(), $param->getChannel())) { |
377 | if (version_compare($param->_installRegistry->packageInfo($param->getPackage(), 'version', |
377 | if (version_compare($param->_installRegistry->packageInfo($param->getPackage(), 'version', |
378 | $param->getChannel()), $param->getVersion(), '==')) { |
378 | $param->getChannel()), $param->getVersion(), '==')) { |
379 | if (!isset($options['force'])) { |
379 | if (!isset($options['force'])) { |
380 | $info = $param->getParsedPackage(); |
380 | $info = $param->getParsedPackage(); |
381 | unset($info['version']); |
381 | unset($info['version']); |
382 | unset($info['state']); |
382 | unset($info['state']); |
383 | if (!isset($options['soft'])) { |
383 | if (!isset($options['soft'])) { |
384 | $param->_downloader->log(1, 'Skipping package "' . |
384 | $param->_downloader->log(1, 'Skipping package "' . |
385 | $param->getShortName() . |
385 | $param->getShortName() . |
386 | '", already installed as version ' . |
386 | '", already installed as version ' . |
387 | $param->_installRegistry->packageInfo($param->getPackage(), |
387 | $param->_installRegistry->packageInfo($param->getPackage(), |
388 | 'version', $param->getChannel())); |
388 | 'version', $param->getChannel())); |
389 | }
|
389 | }
|
390 | $params[$i] = false; |
390 | $params[$i] = false; |
391 | }
|
391 | }
|
392 | } elseif (!isset($options['force']) && !isset($options['upgrade']) && |
392 | } elseif (!isset($options['force']) && !isset($options['upgrade']) && |
393 | !isset($options['soft'])) { |
393 | !isset($options['soft'])) { |
394 | $info = $param->getParsedPackage(); |
394 | $info = $param->getParsedPackage(); |
395 | $param->_downloader->log(1, 'Skipping package "' . |
395 | $param->_downloader->log(1, 'Skipping package "' . |
396 | $param->getShortName() . |
396 | $param->getShortName() . |
397 | '", already installed as version ' . |
397 | '", already installed as version ' . |
398 | $param->_installRegistry->packageInfo($param->getPackage(), 'version', |
398 | $param->_installRegistry->packageInfo($param->getPackage(), 'version', |
399 | $param->getChannel())); |
399 | $param->getChannel())); |
400 | $params[$i] = false; |
400 | $params[$i] = false; |
401 | }
|
401 | }
|
402 | }
|
402 | }
|
403 | }
|
403 | }
|
404 | }
|
404 | }
|
405 | PEAR_Downloader_Package::removeDuplicates($params); |
405 | PEAR_Downloader_Package::removeDuplicates($params); |
406 | }
|
406 | }
|
407 | 407 | ||
408 | function _detect2($deps, $pname, $options, $params) |
408 | function _detect2($deps, $pname, $options, $params) |
409 | {
|
409 | {
|
410 | $this->_downloadDeps = array(); |
410 | $this->_downloadDeps = array(); |
411 | $groupnotfound = false; |
411 | $groupnotfound = false; |
412 | foreach (array('package', 'subpackage') as $packagetype) { |
412 | foreach (array('package', 'subpackage') as $packagetype) { |
413 | // get required dependency group
|
413 | // get required dependency group
|
414 | if (isset($deps['required'][$packagetype])) { |
414 | if (isset($deps['required'][$packagetype])) { |
415 | if (isset($deps['required'][$packagetype][0])) { |
415 | if (isset($deps['required'][$packagetype][0])) { |
416 | foreach ($deps['required'][$packagetype] as $dep) { |
416 | foreach ($deps['required'][$packagetype] as $dep) { |
417 | if (isset($dep['conflicts'])) { |
417 | if (isset($dep['conflicts'])) { |
418 | // skip any package that this package conflicts with
|
418 | // skip any package that this package conflicts with
|
419 | continue; |
419 | continue; |
420 | }
|
420 | }
|
421 | $ret = $this->_detect2Dep($dep, $pname, 'required', $params); |
421 | $ret = $this->_detect2Dep($dep, $pname, 'required', $params); |
422 | if (is_array($ret)) { |
422 | if (is_array($ret)) { |
423 | $this->_downloadDeps[] = $ret; |
423 | $this->_downloadDeps[] = $ret; |
424 | }
|
424 | }
|
425 | }
|
425 | }
|
426 | } else { |
426 | } else { |
427 | $dep = $deps['required'][$packagetype]; |
427 | $dep = $deps['required'][$packagetype]; |
428 | if (!isset($dep['conflicts'])) { |
428 | if (!isset($dep['conflicts'])) { |
429 | // skip any package that this package conflicts with
|
429 | // skip any package that this package conflicts with
|
430 | $ret = $this->_detect2Dep($dep, $pname, 'required', $params); |
430 | $ret = $this->_detect2Dep($dep, $pname, 'required', $params); |
431 | if (is_array($ret)) { |
431 | if (is_array($ret)) { |
432 | $this->_downloadDeps[] = $ret; |
432 | $this->_downloadDeps[] = $ret; |
433 | }
|
433 | }
|
434 | }
|
434 | }
|
435 | }
|
435 | }
|
436 | }
|
436 | }
|
437 | // get optional dependency group, if any
|
437 | // get optional dependency group, if any
|
438 | if (isset($deps['optional'][$packagetype])) { |
438 | if (isset($deps['optional'][$packagetype])) { |
439 | $skipnames = array(); |
439 | $skipnames = array(); |
440 | if (!isset($deps['optional'][$packagetype][0])) { |
440 | if (!isset($deps['optional'][$packagetype][0])) { |
441 | $deps['optional'][$packagetype] = array($deps['optional'][$packagetype]); |
441 | $deps['optional'][$packagetype] = array($deps['optional'][$packagetype]); |
442 | }
|
442 | }
|
443 | foreach ($deps['optional'][$packagetype] as $dep) { |
443 | foreach ($deps['optional'][$packagetype] as $dep) { |
444 | $skip = false; |
444 | $skip = false; |
445 | if (!isset($options['alldeps'])) { |
445 | if (!isset($options['alldeps'])) { |
446 | $dep['package'] = $dep['name']; |
446 | $dep['package'] = $dep['name']; |
447 | if (!isset($options['soft'])) { |
447 | if (!isset($options['soft'])) { |
448 | $this->_downloader->log(3, 'Notice: package "' . |
448 | $this->_downloader->log(3, 'Notice: package "' . |
449 | $this->_registry->parsedPackageNameToString($this->getParsedPackage(), |
449 | $this->_registry->parsedPackageNameToString($this->getParsedPackage(), |
450 | true) . '" optional dependency "' . |
450 | true) . '" optional dependency "' . |
451 | $this->_registry->parsedPackageNameToString(array('package' => |
451 | $this->_registry->parsedPackageNameToString(array('package' => |
452 | $dep['name'], 'channel' => 'pear.php.net'), true) . |
452 | $dep['name'], 'channel' => 'pear.php.net'), true) . |
453 | '" will not be automatically downloaded'); |
453 | '" will not be automatically downloaded'); |
454 | }
|
454 | }
|
455 | $skipnames[] = $this->_registry->parsedPackageNameToString($dep, true); |
455 | $skipnames[] = $this->_registry->parsedPackageNameToString($dep, true); |
456 | $skip = true; |
456 | $skip = true; |
457 | unset($dep['package']); |
457 | unset($dep['package']); |
458 | }
|
458 | }
|
459 | if (!($ret = $this->_detect2Dep($dep, $pname, 'optional', $params))) { |
459 | if (!($ret = $this->_detect2Dep($dep, $pname, 'optional', $params))) { |
460 | $dep['package'] = $dep['name']; |
460 | $dep['package'] = $dep['name']; |
461 | $skip = count($skipnames) ? |
461 | $skip = count($skipnames) ? |
462 | $skipnames[count($skipnames) - 1] : ''; |
462 | $skipnames[count($skipnames) - 1] : ''; |
463 | if ($skip == |
463 | if ($skip == |
464 | $this->_registry->parsedPackageNameToString($dep, true)) { |
464 | $this->_registry->parsedPackageNameToString($dep, true)) { |
465 | array_pop($skipnames); |
465 | array_pop($skipnames); |
466 | }
|
466 | }
|
467 | }
|
467 | }
|
468 | if (!$skip && is_array($ret)) { |
468 | if (!$skip && is_array($ret)) { |
469 | $this->_downloadDeps[] = $ret; |
469 | $this->_downloadDeps[] = $ret; |
470 | }
|
470 | }
|
471 | }
|
471 | }
|
472 | if (count($skipnames)) { |
472 | if (count($skipnames)) { |
473 | if (!isset($options['soft'])) { |
473 | if (!isset($options['soft'])) { |
474 | $this->_downloader->log(1, 'Did not download optional dependencies: ' . |
474 | $this->_downloader->log(1, 'Did not download optional dependencies: ' . |
475 | implode(', ', $skipnames) . |
475 | implode(', ', $skipnames) . |
476 | ', use --alldeps to download automatically'); |
476 | ', use --alldeps to download automatically'); |
477 | }
|
477 | }
|
478 | }
|
478 | }
|
479 | }
|
479 | }
|
480 | // get requested dependency group, if any
|
480 | // get requested dependency group, if any
|
481 | $groupname = $this->getGroup(); |
481 | $groupname = $this->getGroup(); |
482 | $explicit = $this->_explicitGroup; |
482 | $explicit = $this->_explicitGroup; |
483 | if (!$groupname) { |
483 | if (!$groupname) { |
484 | if ($this->canDefault()) { |
484 | if ($this->canDefault()) { |
485 | $groupname = 'default'; // try the default dependency group |
485 | $groupname = 'default'; // try the default dependency group |
486 | } else { |
486 | } else { |
487 | continue; |
487 | continue; |
488 | }
|
488 | }
|
489 | }
|
489 | }
|
490 | if ($groupnotfound) { |
490 | if ($groupnotfound) { |
491 | continue; |
491 | continue; |
492 | }
|
492 | }
|
493 | if (isset($deps['group'])) { |
493 | if (isset($deps['group'])) { |
494 | if (isset($deps['group']['attribs'])) { |
494 | if (isset($deps['group']['attribs'])) { |
495 | if (strtolower($deps['group']['attribs']['name']) == strtolower($groupname)) { |
495 | if (strtolower($deps['group']['attribs']['name']) == strtolower($groupname)) { |
496 | $group = $deps['group']; |
496 | $group = $deps['group']; |
497 | } elseif ($explicit) { |
497 | } elseif ($explicit) { |
498 | if (!isset($options['soft'])) { |
498 | if (!isset($options['soft'])) { |
499 | $this->_downloader->log(0, 'Warning: package "' . |
499 | $this->_downloader->log(0, 'Warning: package "' . |
500 | $this->_registry->parsedPackageNameToString($pname, true) . |
500 | $this->_registry->parsedPackageNameToString($pname, true) . |
501 | '" has no dependency ' . 'group named "' . $groupname . '"'); |
501 | '" has no dependency ' . 'group named "' . $groupname . '"'); |
502 | }
|
502 | }
|
503 | $groupnotfound = true; |
503 | $groupnotfound = true; |
504 | continue; |
504 | continue; |
505 | }
|
505 | }
|
506 | } else { |
506 | } else { |
507 | $found = false; |
507 | $found = false; |
508 | foreach ($deps['group'] as $group) { |
508 | foreach ($deps['group'] as $group) { |
509 | if (strtolower($group['attribs']['name']) == strtolower($groupname)) { |
509 | if (strtolower($group['attribs']['name']) == strtolower($groupname)) { |
510 | $found = true; |
510 | $found = true; |
511 | break; |
511 | break; |
512 | }
|
512 | }
|
513 | }
|
513 | }
|
514 | if (!$found) { |
514 | if (!$found) { |
515 | if ($explicit) { |
515 | if ($explicit) { |
516 | if (!isset($options['soft'])) { |
516 | if (!isset($options['soft'])) { |
517 | $this->_downloader->log(0, 'Warning: package "' . |
517 | $this->_downloader->log(0, 'Warning: package "' . |
518 | $this->_registry->parsedPackageNameToString($pname, true) . |
518 | $this->_registry->parsedPackageNameToString($pname, true) . |
519 | '" has no dependency ' . 'group named "' . $groupname . '"'); |
519 | '" has no dependency ' . 'group named "' . $groupname . '"'); |
520 | }
|
520 | }
|
521 | }
|
521 | }
|
522 | $groupnotfound = true; |
522 | $groupnotfound = true; |
523 | continue; |
523 | continue; |
524 | }
|
524 | }
|
525 | }
|
525 | }
|
526 | }
|
526 | }
|
527 | if (isset($group)) { |
527 | if (isset($group)) { |
528 | if (isset($group[$packagetype])) { |
528 | if (isset($group[$packagetype])) { |
529 | if (isset($group[$packagetype][0])) { |
529 | if (isset($group[$packagetype][0])) { |
530 | foreach ($group[$packagetype] as $dep) { |
530 | foreach ($group[$packagetype] as $dep) { |
531 | $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' . |
531 | $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' . |
532 | $group['attribs']['name'] . '"', $params); |
532 | $group['attribs']['name'] . '"', $params); |
533 | if (is_array($ret)) { |
533 | if (is_array($ret)) { |
534 | $this->_downloadDeps[] = $ret; |
534 | $this->_downloadDeps[] = $ret; |
535 | }
|
535 | }
|
536 | }
|
536 | }
|
537 | } else { |
537 | } else { |
538 | $ret = $this->_detect2Dep($group[$packagetype], $pname, |
538 | $ret = $this->_detect2Dep($group[$packagetype], $pname, |
539 | 'dependency group "' . |
539 | 'dependency group "' . |
540 | $group['attribs']['name'] . '"', $params); |
540 | $group['attribs']['name'] . '"', $params); |
541 | if (is_array($ret)) { |
541 | if (is_array($ret)) { |
542 | $this->_downloadDeps[] = $ret; |
542 | $this->_downloadDeps[] = $ret; |
543 | }
|
543 | }
|
544 | }
|
544 | }
|
545 | }
|
545 | }
|
546 | }
|
546 | }
|
547 | }
|
547 | }
|
548 | }
|
548 | }
|
549 | 549 | ||
550 | function _detect2Dep($dep, $pname, $group, $params) |
550 | function _detect2Dep($dep, $pname, $group, $params) |
551 | {
|
551 | {
|
552 | if (isset($dep['conflicts'])) { |
552 | if (isset($dep['conflicts'])) { |
553 | return true; |
553 | return true; |
554 | }
|
554 | }
|
555 | $options = $this->_downloader->getOptions(); |
555 | $options = $this->_downloader->getOptions(); |
556 | if (isset($dep['uri'])) { |
556 | if (isset($dep['uri'])) { |
557 | return array('uri' => $dep['uri'], 'dep' => $dep);; |
557 | return array('uri' => $dep['uri'], 'dep' => $dep);; |
558 | }
|
558 | }
|
559 | $testdep = $dep; |
559 | $testdep = $dep; |
560 | $testdep['package'] = $dep['name']; |
560 | $testdep['package'] = $dep['name']; |
561 | if (PEAR_Downloader_Package::willDownload($testdep, $params)) { |
561 | if (PEAR_Downloader_Package::willDownload($testdep, $params)) { |
562 | $dep['package'] = $dep['name']; |
562 | $dep['package'] = $dep['name']; |
563 | if (!isset($options['soft'])) { |
563 | if (!isset($options['soft'])) { |
564 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group . |
564 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group . |
565 | ' dependency "' . |
565 | ' dependency "' . |
566 | $this->_registry->parsedPackageNameToString($dep, true) . |
566 | $this->_registry->parsedPackageNameToString($dep, true) . |
567 | '", will be installed'); |
567 | '", will be installed'); |
568 | }
|
568 | }
|
569 | return false; |
569 | return false; |
570 | }
|
570 | }
|
571 | $options = $this->_downloader->getOptions(); |
571 | $options = $this->_downloader->getOptions(); |
572 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
572 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
573 | if ($this->_explicitState) { |
573 | if ($this->_explicitState) { |
574 | $pname['state'] = $this->_explicitState; |
574 | $pname['state'] = $this->_explicitState; |
575 | }
|
575 | }
|
576 | $url = |
576 | $url = |
577 | $this->_downloader->_getDepPackageDownloadUrl($dep, $pname); |
577 | $this->_downloader->_getDepPackageDownloadUrl($dep, $pname); |
578 | if (PEAR::isError($url)) { |
578 | if (PEAR::isError($url)) { |
579 | PEAR::popErrorHandling(); |
579 | PEAR::popErrorHandling(); |
580 | return $url; |
580 | return $url; |
581 | }
|
581 | }
|
582 | $dep['package'] = $dep['name']; |
582 | $dep['package'] = $dep['name']; |
583 | $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, $group == 'optional' && |
583 | $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, $group == 'optional' && |
584 | !isset($options['alldeps']), true); |
584 | !isset($options['alldeps']), true); |
585 | PEAR::popErrorHandling(); |
585 | PEAR::popErrorHandling(); |
586 | if (PEAR::isError($ret)) { |
586 | if (PEAR::isError($ret)) { |
587 | if (!isset($options['soft'])) { |
587 | if (!isset($options['soft'])) { |
588 | $this->_downloader->log(0, $ret->getMessage()); |
588 | $this->_downloader->log(0, $ret->getMessage()); |
589 | }
|
589 | }
|
590 | return false; |
590 | return false; |
591 | } else { |
591 | } else { |
592 | // check to see if a dep is already installed and is the same or newer
|
592 | // check to see if a dep is already installed and is the same or newer
|
593 | if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) { |
593 | if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) { |
594 | $oper = 'has'; |
594 | $oper = 'has'; |
595 | } else { |
595 | } else { |
596 | $oper = 'gt'; |
596 | $oper = 'gt'; |
597 | }
|
597 | }
|
598 | // do not try to move this before getDepPackageDownloadURL
|
598 | // do not try to move this before getDepPackageDownloadURL
|
599 | // we can't determine whether upgrade is necessary until we know what
|
599 | // we can't determine whether upgrade is necessary until we know what
|
600 | // version would be downloaded
|
600 | // version would be downloaded
|
601 | if (!isset($options['force']) && $this->isInstalled($ret, $oper)) { |
601 | if (!isset($options['force']) && $this->isInstalled($ret, $oper)) { |
602 | $version = $this->_installRegistry->packageInfo($dep['name'], 'version', |
602 | $version = $this->_installRegistry->packageInfo($dep['name'], 'version', |
603 | $dep['channel']); |
603 | $dep['channel']); |
604 | $dep['package'] = $dep['name']; |
604 | $dep['package'] = $dep['name']; |
605 | if (!isset($options['soft'])) { |
605 | if (!isset($options['soft'])) { |
606 | $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group . |
606 | $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group . |
607 | ' dependency "' . |
607 | ' dependency "' . |
608 | $this->_registry->parsedPackageNameToString($dep, true) . |
608 | $this->_registry->parsedPackageNameToString($dep, true) . |
609 | '" version ' . $url['version'] . ', already installed as version ' . |
609 | '" version ' . $url['version'] . ', already installed as version ' . |
610 | $version); |
610 | $version); |
611 | }
|
611 | }
|
612 | return false; |
612 | return false; |
613 | }
|
613 | }
|
614 | }
|
614 | }
|
615 | if (isset($dep['nodefault'])) { |
615 | if (isset($dep['nodefault'])) { |
616 | $ret['nodefault'] = true; |
616 | $ret['nodefault'] = true; |
617 | }
|
617 | }
|
618 | return $ret; |
618 | return $ret; |
619 | }
|
619 | }
|
620 | 620 | ||
621 | function _detect1($deps, $pname, $options, $params) |
621 | function _detect1($deps, $pname, $options, $params) |
622 | {
|
622 | {
|
623 | $this->_downloadDeps = array(); |
623 | $this->_downloadDeps = array(); |
624 | $skipnames = array(); |
624 | $skipnames = array(); |
625 | foreach ($deps as $dep) { |
625 | foreach ($deps as $dep) { |
626 | $nodownload = false; |
626 | $nodownload = false; |
627 | if ($dep['type'] == 'pkg') { |
627 | if ($dep['type'] == 'pkg') { |
628 | $dep['channel'] = 'pear.php.net'; |
628 | $dep['channel'] = 'pear.php.net'; |
629 | $dep['package'] = $dep['name']; |
629 | $dep['package'] = $dep['name']; |
630 | switch ($dep['rel']) { |
630 | switch ($dep['rel']) { |
631 | case 'not' : |
631 | case 'not' : |
632 | continue 2; |
632 | continue 2; |
633 | case 'ge' : |
633 | case 'ge' : |
634 | case 'eq' : |
634 | case 'eq' : |
635 | case 'gt' : |
635 | case 'gt' : |
636 | case 'has' : |
636 | case 'has' : |
637 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
637 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
638 | 'required' : |
638 | 'required' : |
639 | 'optional'; |
639 | 'optional'; |
640 | if (PEAR_Downloader_Package::willDownload($dep, $params)) { |
640 | if (PEAR_Downloader_Package::willDownload($dep, $params)) { |
641 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group |
641 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group |
642 | . ' dependency "' . |
642 | . ' dependency "' . |
643 | $this->_registry->parsedPackageNameToString($dep, true) . |
643 | $this->_registry->parsedPackageNameToString($dep, true) . |
644 | '", will be installed'); |
644 | '", will be installed'); |
645 | continue 2; |
645 | continue 2; |
646 | }
|
646 | }
|
647 | $fakedp = new PEAR_PackageFile_v1; |
647 | $fakedp = new PEAR_PackageFile_v1; |
648 | $fakedp->setPackage($dep['name']); |
648 | $fakedp->setPackage($dep['name']); |
649 | // skip internet check if we are not upgrading (bug #5810)
|
649 | // skip internet check if we are not upgrading (bug #5810)
|
650 | if (!isset($options['upgrade']) && $this->isInstalled( |
650 | if (!isset($options['upgrade']) && $this->isInstalled( |
651 | $fakedp, $dep['rel'])) { |
651 | $fakedp, $dep['rel'])) { |
652 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group |
652 | $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group |
653 | . ' dependency "' . |
653 | . ' dependency "' . |
654 | $this->_registry->parsedPackageNameToString($dep, true) . |
654 | $this->_registry->parsedPackageNameToString($dep, true) . |
655 | '", is already installed'); |
655 | '", is already installed'); |
656 | continue 2; |
656 | continue 2; |
657 | }
|
657 | }
|
658 | }
|
658 | }
|
659 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
659 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
660 | if ($this->_explicitState) { |
660 | if ($this->_explicitState) { |
661 | $pname['state'] = $this->_explicitState; |
661 | $pname['state'] = $this->_explicitState; |
662 | }
|
662 | }
|
663 | $url = |
663 | $url = |
664 | $this->_downloader->_getDepPackageDownloadUrl($dep, $pname); |
664 | $this->_downloader->_getDepPackageDownloadUrl($dep, $pname); |
665 | $chan = 'pear.php.net'; |
665 | $chan = 'pear.php.net'; |
666 | if (PEAR::isError($url)) { |
666 | if (PEAR::isError($url)) { |
667 | // check to see if this is a pecl package that has jumped
|
667 | // check to see if this is a pecl package that has jumped
|
668 | // from pear.php.net to pecl.php.net channel
|
668 | // from pear.php.net to pecl.php.net channel
|
669 | if (!class_exists('PEAR_Dependency2')) { |
669 | if (!class_exists('PEAR_Dependency2')) { |
670 | require_once 'PEAR/Dependency2.php'; |
670 | require_once 'PEAR/Dependency2.php'; |
671 | }
|
671 | }
|
672 | $newdep = PEAR_Dependency2::normalizeDep($dep); |
672 | $newdep = PEAR_Dependency2::normalizeDep($dep); |
673 | $newdep = $newdep[0]; |
673 | $newdep = $newdep[0]; |
674 | $newdep['channel'] = 'pecl.php.net'; |
674 | $newdep['channel'] = 'pecl.php.net'; |
675 | $chan = 'pecl.php.net'; |
675 | $chan = 'pecl.php.net'; |
676 | $url = |
676 | $url = |
677 | $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname); |
677 | $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname); |
678 | $obj = &$this->_installRegistry->getPackage($dep['name']); |
678 | $obj = &$this->_installRegistry->getPackage($dep['name']); |
679 | if (PEAR::isError($url)) { |
679 | if (PEAR::isError($url)) { |
680 | PEAR::popErrorHandling(); |
680 | PEAR::popErrorHandling(); |
681 | if ($obj !== null && $this->isInstalled($obj, $dep['rel'])) { |
681 | if ($obj !== null && $this->isInstalled($obj, $dep['rel'])) { |
682 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
682 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
683 | 'required' : |
683 | 'required' : |
684 | 'optional'; |
684 | 'optional'; |
685 | $dep['package'] = $dep['name']; |
685 | $dep['package'] = $dep['name']; |
686 | if (!isset($options['soft'])) { |
686 | if (!isset($options['soft'])) { |
687 | $this->_downloader->log(3, $this->getShortName() . |
687 | $this->_downloader->log(3, $this->getShortName() . |
688 | ': Skipping ' . $group . ' dependency "' . |
688 | ': Skipping ' . $group . ' dependency "' . |
689 | $this->_registry->parsedPackageNameToString($dep, true) . |
689 | $this->_registry->parsedPackageNameToString($dep, true) . |
690 | '", already installed as version ' . $obj->getVersion()); |
690 | '", already installed as version ' . $obj->getVersion()); |
691 | }
|
691 | }
|
692 | $skip = count($skipnames) ? |
692 | $skip = count($skipnames) ? |
693 | $skipnames[count($skipnames) - 1] : ''; |
693 | $skipnames[count($skipnames) - 1] : ''; |
694 | if ($skip == |
694 | if ($skip == |
695 | $this->_registry->parsedPackageNameToString($dep, true)) { |
695 | $this->_registry->parsedPackageNameToString($dep, true)) { |
696 | array_pop($skipnames); |
696 | array_pop($skipnames); |
697 | }
|
697 | }
|
698 | continue; |
698 | continue; |
699 | } else { |
699 | } else { |
700 | if (isset($dep['optional']) && $dep['optional'] == 'yes') { |
700 | if (isset($dep['optional']) && $dep['optional'] == 'yes') { |
701 | $this->_downloader->log(2, $this->getShortName() . |
701 | $this->_downloader->log(2, $this->getShortName() . |
702 | ': Skipping optional dependency "' . |
702 | ': Skipping optional dependency "' . |
703 | $this->_registry->parsedPackageNameToString($dep, true) . |
703 | $this->_registry->parsedPackageNameToString($dep, true) . |
704 | '", no releases exist'); |
704 | '", no releases exist'); |
705 | continue; |
705 | continue; |
706 | } else { |
706 | } else { |
707 | return $url; |
707 | return $url; |
708 | }
|
708 | }
|
709 | }
|
709 | }
|
710 | }
|
710 | }
|
711 | }
|
711 | }
|
712 | PEAR::popErrorHandling(); |
712 | PEAR::popErrorHandling(); |
713 | if (!isset($options['alldeps'])) { |
713 | if (!isset($options['alldeps'])) { |
714 | if (isset($dep['optional']) && $dep['optional'] == 'yes') { |
714 | if (isset($dep['optional']) && $dep['optional'] == 'yes') { |
715 | if (!isset($options['soft'])) { |
715 | if (!isset($options['soft'])) { |
716 | $this->_downloader->log(3, 'Notice: package "' . |
716 | $this->_downloader->log(3, 'Notice: package "' . |
717 | $this->getShortName() . |
717 | $this->getShortName() . |
718 | '" optional dependency "' . |
718 | '" optional dependency "' . |
719 | $this->_registry->parsedPackageNameToString( |
719 | $this->_registry->parsedPackageNameToString( |
720 | array('channel' => $chan, 'package' => |
720 | array('channel' => $chan, 'package' => |
721 | $dep['name']), true) . |
721 | $dep['name']), true) . |
722 | '" will not be automatically downloaded'); |
722 | '" will not be automatically downloaded'); |
723 | }
|
723 | }
|
724 | $skipnames[] = $this->_registry->parsedPackageNameToString( |
724 | $skipnames[] = $this->_registry->parsedPackageNameToString( |
725 | array('channel' => $chan, 'package' => |
725 | array('channel' => $chan, 'package' => |
726 | $dep['name']), true); |
726 | $dep['name']), true); |
727 | $nodownload = true; |
727 | $nodownload = true; |
728 | }
|
728 | }
|
729 | }
|
729 | }
|
730 | if (!isset($options['alldeps']) && !isset($options['onlyreqdeps'])) { |
730 | if (!isset($options['alldeps']) && !isset($options['onlyreqdeps'])) { |
731 | if (!isset($dep['optional']) || $dep['optional'] == 'no') { |
731 | if (!isset($dep['optional']) || $dep['optional'] == 'no') { |
732 | if (!isset($options['soft'])) { |
732 | if (!isset($options['soft'])) { |
733 | $this->_downloader->log(3, 'Notice: package "' . |
733 | $this->_downloader->log(3, 'Notice: package "' . |
734 | $this->getShortName() . |
734 | $this->getShortName() . |
735 | '" required dependency "' . |
735 | '" required dependency "' . |
736 | $this->_registry->parsedPackageNameToString( |
736 | $this->_registry->parsedPackageNameToString( |
737 | array('channel' => $chan, 'package' => |
737 | array('channel' => $chan, 'package' => |
738 | $dep['name']), true) . |
738 | $dep['name']), true) . |
739 | '" will not be automatically downloaded'); |
739 | '" will not be automatically downloaded'); |
740 | }
|
740 | }
|
741 | $skipnames[] = $this->_registry->parsedPackageNameToString( |
741 | $skipnames[] = $this->_registry->parsedPackageNameToString( |
742 | array('channel' => $chan, 'package' => |
742 | array('channel' => $chan, 'package' => |
743 | $dep['name']), true); |
743 | $dep['name']), true); |
744 | $nodownload = true; |
744 | $nodownload = true; |
745 | }
|
745 | }
|
746 | }
|
746 | }
|
747 | // check to see if a dep is already installed
|
747 | // check to see if a dep is already installed
|
748 | // do not try to move this before getDepPackageDownloadURL
|
748 | // do not try to move this before getDepPackageDownloadURL
|
749 | // we can't determine whether upgrade is necessary until we know what
|
749 | // we can't determine whether upgrade is necessary until we know what
|
750 | // version would be downloaded
|
750 | // version would be downloaded
|
751 | if (!isset($options['force']) && $this->isInstalled( |
751 | if (!isset($options['force']) && $this->isInstalled( |
752 | $url, $dep['rel'])) { |
752 | $url, $dep['rel'])) { |
753 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
753 | $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ? |
754 | 'required' : |
754 | 'required' : |
755 | 'optional'; |
755 | 'optional'; |
756 | $dep['package'] = $dep['name']; |
756 | $dep['package'] = $dep['name']; |
757 | if (isset($newdep)) { |
757 | if (isset($newdep)) { |
758 | $version = $this->_installRegistry->packageInfo($newdep['name'], 'version', |
758 | $version = $this->_installRegistry->packageInfo($newdep['name'], 'version', |
759 | $newdep['channel']); |
759 | $newdep['channel']); |
760 | } else { |
760 | } else { |
761 | $version = $this->_installRegistry->packageInfo($dep['name'], 'version'); |
761 | $version = $this->_installRegistry->packageInfo($dep['name'], 'version'); |
762 | }
|
762 | }
|
763 | $dep['version'] = $url['version']; |
763 | $dep['version'] = $url['version']; |
764 | if (!isset($options['soft'])) { |
764 | if (!isset($options['soft'])) { |
765 | $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group . |
765 | $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group . |
766 | ' dependency "' . |
766 | ' dependency "' . |
767 | $this->_registry->parsedPackageNameToString($dep, true) . |
767 | $this->_registry->parsedPackageNameToString($dep, true) . |
768 | '", already installed as version ' . $version); |
768 | '", already installed as version ' . $version); |
769 | }
|
769 | }
|
770 | $skip = count($skipnames) ? |
770 | $skip = count($skipnames) ? |
771 | $skipnames[count($skipnames) - 1] : ''; |
771 | $skipnames[count($skipnames) - 1] : ''; |
772 | if ($skip == |
772 | if ($skip == |
773 | $this->_registry->parsedPackageNameToString($dep, true)) { |
773 | $this->_registry->parsedPackageNameToString($dep, true)) { |
774 | array_pop($skipnames); |
774 | array_pop($skipnames); |
775 | }
|
775 | }
|
776 | continue; |
776 | continue; |
777 | }
|
777 | }
|
778 | if ($nodownload) { |
778 | if ($nodownload) { |
779 | continue; |
779 | continue; |
780 | }
|
780 | }
|
781 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
781 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
782 | if (isset($newdep)) { |
782 | if (isset($newdep)) { |
783 | $dep = $newdep; |
783 | $dep = $newdep; |
784 | }
|
784 | }
|
785 | $dep['package'] = $dep['name']; |
785 | $dep['package'] = $dep['name']; |
786 | $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, |
786 | $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, |
787 | isset($dep['optional']) && $dep['optional'] == 'yes' && |
787 | isset($dep['optional']) && $dep['optional'] == 'yes' && |
788 | !isset($options['alldeps']), true); |
788 | !isset($options['alldeps']), true); |
789 | PEAR::popErrorHandling(); |
789 | PEAR::popErrorHandling(); |
790 | if (PEAR::isError($ret)) { |
790 | if (PEAR::isError($ret)) { |
791 | if (!isset($options['soft'])) { |
791 | if (!isset($options['soft'])) { |
792 | $this->_downloader->log(0, $ret->getMessage()); |
792 | $this->_downloader->log(0, $ret->getMessage()); |
793 | }
|
793 | }
|
794 | continue; |
794 | continue; |
795 | }
|
795 | }
|
796 | $this->_downloadDeps[] = $ret; |
796 | $this->_downloadDeps[] = $ret; |
797 | }
|
797 | }
|
798 | }
|
798 | }
|
799 | if (count($skipnames)) { |
799 | if (count($skipnames)) { |
800 | if (!isset($options['soft'])) { |
800 | if (!isset($options['soft'])) { |
801 | $this->_downloader->log(1, 'Did not download dependencies: ' . |
801 | $this->_downloader->log(1, 'Did not download dependencies: ' . |
802 | implode(', ', $skipnames) . |
802 | implode(', ', $skipnames) . |
803 | ', use --alldeps or --onlyreqdeps to download automatically'); |
803 | ', use --alldeps or --onlyreqdeps to download automatically'); |
804 | }
|
804 | }
|
805 | }
|
805 | }
|
806 | }
|
806 | }
|
807 | 807 | ||
808 | function setDownloadURL($pkg) |
808 | function setDownloadURL($pkg) |
809 | {
|
809 | {
|
810 | $this->_downloadURL = $pkg; |
810 | $this->_downloadURL = $pkg; |
811 | }
|
811 | }
|
812 | 812 | ||
813 | /**
|
813 | /**
|
814 | * Set the package.xml object for this downloaded package
|
814 | * Set the package.xml object for this downloaded package
|
815 | *
|
815 | *
|
816 | * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2 $pkg
|
816 | * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2 $pkg
|
817 | */
|
817 | */
|
818 | function setPackageFile(&$pkg) |
818 | function setPackageFile(&$pkg) |
819 | {
|
819 | {
|
820 | $this->_packagefile = &$pkg; |
820 | $this->_packagefile = &$pkg; |
821 | }
|
821 | }
|
822 | 822 | ||
823 | function getShortName() |
823 | function getShortName() |
824 | {
|
824 | {
|
825 | return $this->_registry->parsedPackageNameToString(array('channel' => $this->getChannel(), |
825 | return $this->_registry->parsedPackageNameToString(array('channel' => $this->getChannel(), |
826 | 'package' => $this->getPackage()), true); |
826 | 'package' => $this->getPackage()), true); |
827 | }
|
827 | }
|
828 | 828 | ||
829 | function getParsedPackage() |
829 | function getParsedPackage() |
830 | {
|
830 | {
|
831 | if (isset($this->_packagefile) || isset($this->_parsedname)) { |
831 | if (isset($this->_packagefile) || isset($this->_parsedname)) { |
832 | return array('channel' => $this->getChannel(), |
832 | return array('channel' => $this->getChannel(), |
833 | 'package' => $this->getPackage(), |
833 | 'package' => $this->getPackage(), |
834 | 'version' => $this->getVersion()); |
834 | 'version' => $this->getVersion()); |
835 | }
|
835 | }
|
836 | return false; |
836 | return false; |
837 | }
|
837 | }
|
838 | 838 | ||
839 | function getDownloadURL() |
839 | function getDownloadURL() |
840 | {
|
840 | {
|
841 | return $this->_downloadURL; |
841 | return $this->_downloadURL; |
842 | }
|
842 | }
|
843 | 843 | ||
844 | function canDefault() |
844 | function canDefault() |
845 | {
|
845 | {
|
846 | if (isset($this->_downloadURL)) { |
846 | if (isset($this->_downloadURL)) { |
847 | if (isset($this->_downloadURL['nodefault'])) { |
847 | if (isset($this->_downloadURL['nodefault'])) { |
848 | return false; |
848 | return false; |
849 | }
|
849 | }
|
850 | }
|
850 | }
|
851 | return true; |
851 | return true; |
852 | }
|
852 | }
|
853 | 853 | ||
854 | function getPackage() |
854 | function getPackage() |
855 | {
|
855 | {
|
856 | if (isset($this->_packagefile)) { |
856 | if (isset($this->_packagefile)) { |
857 | return $this->_packagefile->getPackage(); |
857 | return $this->_packagefile->getPackage(); |
858 | } elseif (isset($this->_downloadURL['info'])) { |
858 | } elseif (isset($this->_downloadURL['info'])) { |
859 | return $this->_downloadURL['info']->getPackage(); |
859 | return $this->_downloadURL['info']->getPackage(); |
860 | } else { |
860 | } else { |
861 | return false; |
861 | return false; |
862 | }
|
862 | }
|
863 | }
|
863 | }
|
864 | 864 | ||
865 | /**
|
865 | /**
|
866 | * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
|
866 | * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
|
867 | */
|
867 | */
|
868 | function isSubpackage(&$pf) |
868 | function isSubpackage(&$pf) |
869 | {
|
869 | {
|
870 | if (isset($this->_packagefile)) { |
870 | if (isset($this->_packagefile)) { |
871 | return $this->_packagefile->isSubpackage($pf); |
871 | return $this->_packagefile->isSubpackage($pf); |
872 | } elseif (isset($this->_downloadURL['info'])) { |
872 | } elseif (isset($this->_downloadURL['info'])) { |
873 | return $this->_downloadURL['info']->isSubpackage($pf); |
873 | return $this->_downloadURL['info']->isSubpackage($pf); |
874 | } else { |
874 | } else { |
875 | return false; |
875 | return false; |
876 | }
|
876 | }
|
877 | }
|
877 | }
|
878 | 878 | ||
879 | function getPackageType() |
879 | function getPackageType() |
880 | {
|
880 | {
|
881 | if (isset($this->_packagefile)) { |
881 | if (isset($this->_packagefile)) { |
882 | return $this->_packagefile->getPackageType(); |
882 | return $this->_packagefile->getPackageType(); |
883 | } elseif (isset($this->_downloadURL['info'])) { |
883 | } elseif (isset($this->_downloadURL['info'])) { |
884 | return $this->_downloadURL['info']->getPackageType(); |
884 | return $this->_downloadURL['info']->getPackageType(); |
885 | } else { |
885 | } else { |
886 | return false; |
886 | return false; |
887 | }
|
887 | }
|
888 | }
|
888 | }
|
889 | 889 | ||
890 | function isBundle() |
890 | function isBundle() |
891 | {
|
891 | {
|
892 | if (isset($this->_packagefile)) { |
892 | if (isset($this->_packagefile)) { |
893 | return $this->_packagefile->getPackageType() == 'bundle'; |
893 | return $this->_packagefile->getPackageType() == 'bundle'; |
894 | } else { |
894 | } else { |
895 | return false; |
895 | return false; |
896 | }
|
896 | }
|
897 | }
|
897 | }
|
898 | 898 | ||
899 | function getPackageXmlVersion() |
899 | function getPackageXmlVersion() |
900 | {
|
900 | {
|
901 | if (isset($this->_packagefile)) { |
901 | if (isset($this->_packagefile)) { |
902 | return $this->_packagefile->getPackagexmlVersion(); |
902 | return $this->_packagefile->getPackagexmlVersion(); |
903 | } elseif (isset($this->_downloadURL['info'])) { |
903 | } elseif (isset($this->_downloadURL['info'])) { |
904 | return $this->_downloadURL['info']->getPackagexmlVersion(); |
904 | return $this->_downloadURL['info']->getPackagexmlVersion(); |
905 | } else { |
905 | } else { |
906 | return '1.0'; |
906 | return '1.0'; |
907 | }
|
907 | }
|
908 | }
|
908 | }
|
909 | 909 | ||
910 | function getChannel() |
910 | function getChannel() |
911 | {
|
911 | {
|
912 | if (isset($this->_packagefile)) { |
912 | if (isset($this->_packagefile)) { |
913 | return $this->_packagefile->getChannel(); |
913 | return $this->_packagefile->getChannel(); |
914 | } elseif (isset($this->_downloadURL['info'])) { |
914 | } elseif (isset($this->_downloadURL['info'])) { |
915 | return $this->_downloadURL['info']->getChannel(); |
915 | return $this->_downloadURL['info']->getChannel(); |
916 | } else { |
916 | } else { |
917 | return false; |
917 | return false; |
918 | }
|
918 | }
|
919 | }
|
919 | }
|
920 | 920 | ||
921 | function getURI() |
921 | function getURI() |
922 | {
|
922 | {
|
923 | if (isset($this->_packagefile)) { |
923 | if (isset($this->_packagefile)) { |
924 | return $this->_packagefile->getURI(); |
924 | return $this->_packagefile->getURI(); |
925 | } elseif (isset($this->_downloadURL['info'])) { |
925 | } elseif (isset($this->_downloadURL['info'])) { |
926 | return $this->_downloadURL['info']->getURI(); |
926 | return $this->_downloadURL['info']->getURI(); |
927 | } else { |
927 | } else { |
928 | return false; |
928 | return false; |
929 | }
|
929 | }
|
930 | }
|
930 | }
|
931 | 931 | ||
932 | function getVersion() |
932 | function getVersion() |
933 | {
|
933 | {
|
934 | if (isset($this->_packagefile)) { |
934 | if (isset($this->_packagefile)) { |
935 | return $this->_packagefile->getVersion(); |
935 | return $this->_packagefile->getVersion(); |
936 | } elseif (isset($this->_downloadURL['version'])) { |
936 | } elseif (isset($this->_downloadURL['version'])) { |
937 | return $this->_downloadURL['version']; |
937 | return $this->_downloadURL['version']; |
938 | } else { |
938 | } else { |
939 | return false; |
939 | return false; |
940 | }
|
940 | }
|
941 | }
|
941 | }
|
942 | 942 | ||
943 | function isCompatible($pf) |
943 | function isCompatible($pf) |
944 | {
|
944 | {
|
945 | if (isset($this->_packagefile)) { |
945 | if (isset($this->_packagefile)) { |
946 | return $this->_packagefile->isCompatible($pf); |
946 | return $this->_packagefile->isCompatible($pf); |
947 | } elseif (isset($this->_downloadURL['info'])) { |
947 | } elseif (isset($this->_downloadURL['info'])) { |
948 | return $this->_downloadURL['info']->isCompatible($pf); |
948 | return $this->_downloadURL['info']->isCompatible($pf); |
949 | } else { |
949 | } else { |
950 | return true; |
950 | return true; |
951 | }
|
951 | }
|
952 | }
|
952 | }
|
953 | 953 | ||
954 | function setGroup($group) |
954 | function setGroup($group) |
955 | {
|
955 | {
|
956 | $this->_parsedname['group'] = $group; |
956 | $this->_parsedname['group'] = $group; |
957 | }
|
957 | }
|
958 | 958 | ||
959 | function getGroup() |
959 | function getGroup() |
960 | {
|
960 | {
|
961 | if (isset($this->_parsedname['group'])) { |
961 | if (isset($this->_parsedname['group'])) { |
962 | return $this->_parsedname['group']; |
962 | return $this->_parsedname['group']; |
963 | } else { |
963 | } else { |
964 | return ''; |
964 | return ''; |
965 | }
|
965 | }
|
966 | }
|
966 | }
|
967 | 967 | ||
968 | function isExtension($name) |
968 | function isExtension($name) |
969 | {
|
969 | {
|
970 | if (isset($this->_packagefile)) { |
970 | if (isset($this->_packagefile)) { |
971 | return $this->_packagefile->isExtension($name); |
971 | return $this->_packagefile->isExtension($name); |
972 | } elseif (isset($this->_downloadURL['info'])) { |
972 | } elseif (isset($this->_downloadURL['info'])) { |
973 | if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') { |
973 | if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') { |
974 | return $this->_downloadURL['info']->getProvidesExtension() == $name; |
974 | return $this->_downloadURL['info']->getProvidesExtension() == $name; |
975 | } else { |
975 | } else { |
976 | return false; |
976 | return false; |
977 | }
|
977 | }
|
978 | } else { |
978 | } else { |
979 | return false; |
979 | return false; |
980 | }
|
980 | }
|
981 | }
|
981 | }
|
982 | 982 | ||
983 | function getDeps() |
983 | function getDeps() |
984 | {
|
984 | {
|
985 | if (isset($this->_packagefile)) { |
985 | if (isset($this->_packagefile)) { |
986 | $ver = $this->_packagefile->getPackagexmlVersion(); |
986 | $ver = $this->_packagefile->getPackagexmlVersion(); |
987 | if (version_compare($ver, '2.0', '>=')) { |
987 | if (version_compare($ver, '2.0', '>=')) { |
988 | return $this->_packagefile->getDeps(true); |
988 | return $this->_packagefile->getDeps(true); |
989 | } else { |
989 | } else { |
990 | return $this->_packagefile->getDeps(); |
990 | return $this->_packagefile->getDeps(); |
991 | }
|
991 | }
|
992 | } elseif (isset($this->_downloadURL['info'])) { |
992 | } elseif (isset($this->_downloadURL['info'])) { |
993 | $ver = $this->_downloadURL['info']->getPackagexmlVersion(); |
993 | $ver = $this->_downloadURL['info']->getPackagexmlVersion(); |
994 | if (version_compare($ver, '2.0', '>=')) { |
994 | if (version_compare($ver, '2.0', '>=')) { |
995 | return $this->_downloadURL['info']->getDeps(true); |
995 | return $this->_downloadURL['info']->getDeps(true); |
996 | } else { |
996 | } else { |
997 | return $this->_downloadURL['info']->getDeps(); |
997 | return $this->_downloadURL['info']->getDeps(); |
998 | }
|
998 | }
|
999 | } else { |
999 | } else { |
1000 | return array(); |
1000 | return array(); |
1001 | }
|
1001 | }
|
1002 | }
|
1002 | }
|
1003 | 1003 | ||
1004 | /**
|
1004 | /**
|
1005 | * @param array Parsed array from {@link PEAR_Registry::parsePackageName()} or a dependency
|
1005 | * @param array Parsed array from {@link PEAR_Registry::parsePackageName()} or a dependency
|
1006 | * returned from getDepDownloadURL()
|
1006 | * returned from getDepDownloadURL()
|
1007 | */
|
1007 | */
|
1008 | function isEqual($param) |
1008 | function isEqual($param) |
1009 | {
|
1009 | {
|
1010 | if (is_object($param)) { |
1010 | if (is_object($param)) { |
1011 | $channel = $param->getChannel(); |
1011 | $channel = $param->getChannel(); |
1012 | $package = $param->getPackage(); |
1012 | $package = $param->getPackage(); |
1013 | if ($param->getURI()) { |
1013 | if ($param->getURI()) { |
1014 | $param = array( |
1014 | $param = array( |
1015 | 'channel' => $param->getChannel(), |
1015 | 'channel' => $param->getChannel(), |
1016 | 'package' => $param->getPackage(), |
1016 | 'package' => $param->getPackage(), |
1017 | 'version' => $param->getVersion(), |
1017 | 'version' => $param->getVersion(), |
1018 | 'uri' => $param->getURI(), |
1018 | 'uri' => $param->getURI(), |
1019 | ); |
1019 | ); |
1020 | } else { |
1020 | } else { |
1021 | $param = array( |
1021 | $param = array( |
1022 | 'channel' => $param->getChannel(), |
1022 | 'channel' => $param->getChannel(), |
1023 | 'package' => $param->getPackage(), |
1023 | 'package' => $param->getPackage(), |
1024 | 'version' => $param->getVersion(), |
1024 | 'version' => $param->getVersion(), |
1025 | ); |
1025 | ); |
1026 | }
|
1026 | }
|
1027 | } else { |
1027 | } else { |
1028 | if (isset($param['uri'])) { |
1028 | if (isset($param['uri'])) { |
1029 | if ($this->getChannel() != '__uri') { |
1029 | if ($this->getChannel() != '__uri') { |
1030 | return false; |
1030 | return false; |
1031 | }
|
1031 | }
|
1032 | return $param['uri'] == $this->getURI(); |
1032 | return $param['uri'] == $this->getURI(); |
1033 | }
|
1033 | }
|
1034 | $package = isset($param['package']) ? $param['package'] : |
1034 | $package = isset($param['package']) ? $param['package'] : |
1035 | $param['info']->getPackage(); |
1035 | $param['info']->getPackage(); |
1036 | $channel = isset($param['channel']) ? $param['channel'] : |
1036 | $channel = isset($param['channel']) ? $param['channel'] : |
1037 | $param['info']->getChannel(); |
1037 | $param['info']->getChannel(); |
1038 | if (isset($param['rel'])) { |
1038 | if (isset($param['rel'])) { |
1039 | if (!class_exists('PEAR_Dependency2')) { |
1039 | if (!class_exists('PEAR_Dependency2')) { |
1040 | require_once 'PEAR/Dependency2.php'; |
1040 | require_once 'PEAR/Dependency2.php'; |
1041 | }
|
1041 | }
|
1042 | $newdep = PEAR_Dependency2::normalizeDep($param); |
1042 | $newdep = PEAR_Dependency2::normalizeDep($param); |
1043 | $newdep = $newdep[0]; |
1043 | $newdep = $newdep[0]; |
1044 | } elseif (isset($param['min'])) { |
1044 | } elseif (isset($param['min'])) { |
1045 | $newdep = $param; |
1045 | $newdep = $param; |
1046 | }
|
1046 | }
|
1047 | }
|
1047 | }
|
1048 | if (isset($newdep)) { |
1048 | if (isset($newdep)) { |
1049 | if (!isset($newdep['min'])) { |
1049 | if (!isset($newdep['min'])) { |
1050 | $newdep['min'] = '0'; |
1050 | $newdep['min'] = '0'; |
1051 | }
|
1051 | }
|
1052 | if (!isset($newdep['max'])) { |
1052 | if (!isset($newdep['max'])) { |
1053 | $newdep['max'] = '100000000000000000000'; |
1053 | $newdep['max'] = '100000000000000000000'; |
1054 | }
|
1054 | }
|
1055 | // use magic to support pecl packages suddenly jumping to the pecl channel
|
1055 | // use magic to support pecl packages suddenly jumping to the pecl channel
|
1056 | // we need to support both dependency possibilities
|
1056 | // we need to support both dependency possibilities
|
1057 | if ($channel == 'pear.php.net' && $this->getChannel() == 'pecl.php.net') { |
1057 | if ($channel == 'pear.php.net' && $this->getChannel() == 'pecl.php.net') { |
1058 | if ($package == $this->getPackage()) { |
1058 | if ($package == $this->getPackage()) { |
1059 | $channel = 'pecl.php.net'; |
1059 | $channel = 'pecl.php.net'; |
1060 | }
|
1060 | }
|
1061 | }
|
1061 | }
|
1062 | if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') { |
1062 | if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') { |
1063 | if ($package == $this->getPackage()) { |
1063 | if ($package == $this->getPackage()) { |
1064 | $channel = 'pear.php.net'; |
1064 | $channel = 'pear.php.net'; |
1065 | }
|
1065 | }
|
1066 | }
|
1066 | }
|
1067 | return (strtolower($package) == strtolower($this->getPackage()) && |
1067 | return (strtolower($package) == strtolower($this->getPackage()) && |
1068 | $channel == $this->getChannel() && |
1068 | $channel == $this->getChannel() && |
1069 | version_compare($newdep['min'], $this->getVersion(), '<=') && |
1069 | version_compare($newdep['min'], $this->getVersion(), '<=') && |
1070 | version_compare($newdep['max'], $this->getVersion(), '>=')); |
1070 | version_compare($newdep['max'], $this->getVersion(), '>=')); |
1071 | }
|
1071 | }
|
1072 | // use magic to support pecl packages suddenly jumping to the pecl channel
|
1072 | // use magic to support pecl packages suddenly jumping to the pecl channel
|
1073 | if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') { |
1073 | if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') { |
1074 | if (strtolower($package) == strtolower($this->getPackage())) { |
1074 | if (strtolower($package) == strtolower($this->getPackage())) { |
1075 | $channel = 'pear.php.net'; |
1075 | $channel = 'pear.php.net'; |
1076 | }
|
1076 | }
|
1077 | }
|
1077 | }
|
1078 | if (isset($param['version'])) { |
1078 | if (isset($param['version'])) { |
1079 | return (strtolower($package) == strtolower($this->getPackage()) && |
1079 | return (strtolower($package) == strtolower($this->getPackage()) && |
1080 | $channel == $this->getChannel() && |
1080 | $channel == $this->getChannel() && |
1081 | $param['version'] == $this->getVersion()); |
1081 | $param['version'] == $this->getVersion()); |
1082 | } else { |
1082 | } else { |
1083 | return strtolower($package) == strtolower($this->getPackage()) && |
1083 | return strtolower($package) == strtolower($this->getPackage()) && |
1084 | $channel == $this->getChannel(); |
1084 | $channel == $this->getChannel(); |
1085 | }
|
1085 | }
|
1086 | }
|
1086 | }
|
1087 | 1087 | ||
1088 | function isInstalled($dep, $oper = '==') |
1088 | function isInstalled($dep, $oper = '==') |
1089 | {
|
1089 | {
|
1090 | if (!$dep) { |
1090 | if (!$dep) { |
1091 | return false; |
1091 | return false; |
1092 | }
|
1092 | }
|
1093 | if ($oper != 'ge' && $oper != 'gt' && $oper != 'has' && $oper != '==') { |
1093 | if ($oper != 'ge' && $oper != 'gt' && $oper != 'has' && $oper != '==') { |
1094 | return false; |
1094 | return false; |
1095 | }
|
1095 | }
|
1096 | if (is_object($dep)) { |
1096 | if (is_object($dep)) { |
1097 | $package = $dep->getPackage(); |
1097 | $package = $dep->getPackage(); |
1098 | $channel = $dep->getChannel(); |
1098 | $channel = $dep->getChannel(); |
1099 | if ($dep->getURI()) { |
1099 | if ($dep->getURI()) { |
1100 | $dep = array( |
1100 | $dep = array( |
1101 | 'uri' => $dep->getURI(), |
1101 | 'uri' => $dep->getURI(), |
1102 | 'version' => $dep->getVersion(), |
1102 | 'version' => $dep->getVersion(), |
1103 | ); |
1103 | ); |
1104 | } else { |
1104 | } else { |
1105 | $dep = array( |
1105 | $dep = array( |
1106 | 'version' => $dep->getVersion(), |
1106 | 'version' => $dep->getVersion(), |
1107 | ); |
1107 | ); |
1108 | }
|
1108 | }
|
1109 | } else { |
1109 | } else { |
1110 | if (isset($dep['uri'])) { |
1110 | if (isset($dep['uri'])) { |
1111 | $channel = '__uri'; |
1111 | $channel = '__uri'; |
1112 | $package = $dep['dep']['name']; |
1112 | $package = $dep['dep']['name']; |
1113 | } else { |
1113 | } else { |
1114 | $channel = $dep['info']->getChannel(); |
1114 | $channel = $dep['info']->getChannel(); |
1115 | $package = $dep['info']->getPackage(); |
1115 | $package = $dep['info']->getPackage(); |
1116 | }
|
1116 | }
|
1117 | }
|
1117 | }
|
1118 | $options = $this->_downloader->getOptions(); |
1118 | $options = $this->_downloader->getOptions(); |
1119 | $test = $this->_installRegistry->packageExists($package, $channel); |
1119 | $test = $this->_installRegistry->packageExists($package, $channel); |
1120 | if (!$test && $channel == 'pecl.php.net') { |
1120 | if (!$test && $channel == 'pecl.php.net') { |
1121 | // do magic to allow upgrading from old pecl packages to new ones
|
1121 | // do magic to allow upgrading from old pecl packages to new ones
|
1122 | $test = $this->_installRegistry->packageExists($package, 'pear.php.net'); |
1122 | $test = $this->_installRegistry->packageExists($package, 'pear.php.net'); |
1123 | $channel = 'pear.php.net'; |
1123 | $channel = 'pear.php.net'; |
1124 | }
|
1124 | }
|
1125 | if ($test) { |
1125 | if ($test) { |
1126 | if (isset($dep['uri'])) { |
1126 | if (isset($dep['uri'])) { |
1127 | if ($this->_installRegistry->packageInfo($package, 'uri', '__uri') == $dep['uri']) { |
1127 | if ($this->_installRegistry->packageInfo($package, 'uri', '__uri') == $dep['uri']) { |
1128 | return true; |
1128 | return true; |
1129 | }
|
1129 | }
|
1130 | }
|
1130 | }
|
1131 | if (isset($options['upgrade'])) { |
1131 | if (isset($options['upgrade'])) { |
1132 | if ($oper == 'has') { |
1132 | if ($oper == 'has') { |
1133 | if (version_compare($this->_installRegistry->packageInfo( |
1133 | if (version_compare($this->_installRegistry->packageInfo( |
1134 | $package, 'version', $channel), |
1134 | $package, 'version', $channel), |
1135 | $dep['version'], '>=')) { |
1135 | $dep['version'], '>=')) { |
1136 | return true; |
1136 | return true; |
1137 | } else { |
1137 | } else { |
1138 | return false; |
1138 | return false; |
1139 | }
|
1139 | }
|
1140 | } else { |
1140 | } else { |
1141 | if (version_compare($this->_installRegistry->packageInfo( |
1141 | if (version_compare($this->_installRegistry->packageInfo( |
1142 | $package, 'version', $channel), |
1142 | $package, 'version', $channel), |
1143 | $dep['version'], '>=')) { |
1143 | $dep['version'], '>=')) { |
1144 | return true; |
1144 | return true; |
1145 | }
|
1145 | }
|
1146 | return false; |
1146 | return false; |
1147 | }
|
1147 | }
|
1148 | }
|
1148 | }
|
1149 | return true; |
1149 | return true; |
1150 | }
|
1150 | }
|
1151 | return false; |
1151 | return false; |
1152 | }
|
1152 | }
|
1153 | 1153 | ||
1154 | /**
|
1154 | /**
|
1155 | * Detect duplicate package names with differing versions
|
1155 | * Detect duplicate package names with differing versions
|
1156 | *
|
1156 | *
|
1157 | * If a user requests to install Date 1.4.6 and Date 1.4.7,
|
1157 | * If a user requests to install Date 1.4.6 and Date 1.4.7,
|
1158 | * for instance, this is a logic error. This method
|
1158 | * for instance, this is a logic error. This method
|
1159 | * detects this situation.
|
1159 | * detects this situation.
|
1160 | *
|
1160 | *
|
1161 | * @param array $params array of PEAR_Downloader_Package objects
|
1161 | * @param array $params array of PEAR_Downloader_Package objects
|
1162 | * @param array $errorparams empty array
|
1162 | * @param array $errorparams empty array
|
1163 | * @return array array of stupid duplicated packages in PEAR_Downloader_Package obejcts
|
1163 | * @return array array of stupid duplicated packages in PEAR_Downloader_Package obejcts
|
1164 | */
|
1164 | */
|
1165 | function detectStupidDuplicates($params, &$errorparams) |
1165 | function detectStupidDuplicates($params, &$errorparams) |
1166 | {
|
1166 | {
|
1167 | $existing = array(); |
1167 | $existing = array(); |
1168 | foreach ($params as $i => $param) { |
1168 | foreach ($params as $i => $param) { |
1169 | $package = $param->getPackage(); |
1169 | $package = $param->getPackage(); |
1170 | $channel = $param->getChannel(); |
1170 | $channel = $param->getChannel(); |
1171 | $group = $param->getGroup(); |
1171 | $group = $param->getGroup(); |
1172 | if (!isset($existing[$channel . '/' . $package])) { |
1172 | if (!isset($existing[$channel . '/' . $package])) { |
1173 | $existing[$channel . '/' . $package] = array(); |
1173 | $existing[$channel . '/' . $package] = array(); |
1174 | }
|
1174 | }
|
1175 | if (!isset($existing[$channel . '/' . $package][$group])) { |
1175 | if (!isset($existing[$channel . '/' . $package][$group])) { |
1176 | $existing[$channel . '/' . $package][$group] = array(); |
1176 | $existing[$channel . '/' . $package][$group] = array(); |
1177 | }
|
1177 | }
|
1178 | $existing[$channel . '/' . $package][$group][] = $i; |
1178 | $existing[$channel . '/' . $package][$group][] = $i; |
1179 | }
|
1179 | }
|
1180 | 1180 | ||
1181 | $indices = array(); |
1181 | $indices = array(); |
1182 | foreach ($existing as $package => $groups) { |
1182 | foreach ($existing as $package => $groups) { |
1183 | foreach ($groups as $group => $dupes) { |
1183 | foreach ($groups as $group => $dupes) { |
1184 | if (count($dupes) > 1) { |
1184 | if (count($dupes) > 1) { |
1185 | $indices = $indices + $dupes; |
1185 | $indices = $indices + $dupes; |
1186 | }
|
1186 | }
|
1187 | }
|
1187 | }
|
1188 | }
|
1188 | }
|
1189 | 1189 | ||
1190 | $indices = array_unique($indices); |
1190 | $indices = array_unique($indices); |
1191 | foreach ($indices as $index) { |
1191 | foreach ($indices as $index) { |
1192 | $errorparams[] = $params[$index]; |
1192 | $errorparams[] = $params[$index]; |
1193 | }
|
1193 | }
|
1194 | return count($errorparams); |
1194 | return count($errorparams); |
1195 | }
|
1195 | }
|
1196 | 1196 | ||
1197 | /**
|
1197 | /**
|
1198 | * @param array
|
1198 | * @param array
|
1199 | * @param bool ignore install groups - for final removal of dupe packages
|
1199 | * @param bool ignore install groups - for final removal of dupe packages
|
1200 | * @static
|
1200 | * @static
|
1201 | */
|
1201 | */
|
1202 | function removeDuplicates(&$params, $ignoreGroups = false) |
1202 | function removeDuplicates(&$params, $ignoreGroups = false) |
1203 | {
|
1203 | {
|
1204 | $pnames = array(); |
1204 | $pnames = array(); |
1205 | foreach ($params as $i => $param) { |
1205 | foreach ($params as $i => $param) { |
1206 | if (!$param) { |
1206 | if (!$param) { |
1207 | continue; |
1207 | continue; |
1208 | }
|
1208 | }
|
1209 | if ($param->getPackage()) { |
1209 | if ($param->getPackage()) { |
1210 | if ($ignoreGroups) { |
1210 | if ($ignoreGroups) { |
1211 | $group = ''; |
1211 | $group = ''; |
1212 | } else { |
1212 | } else { |
1213 | $group = $param->getGroup(); |
1213 | $group = $param->getGroup(); |
1214 | }
|
1214 | }
|
1215 | $pnames[$i] = $param->getChannel() . '/' . |
1215 | $pnames[$i] = $param->getChannel() . '/' . |
1216 | $param->getPackage() . '-' . $param->getVersion() . '#' . $group; |
1216 | $param->getPackage() . '-' . $param->getVersion() . '#' . $group; |
1217 | }
|
1217 | }
|
1218 | }
|
1218 | }
|
1219 | $pnames = array_unique($pnames); |
1219 | $pnames = array_unique($pnames); |
1220 | $unset = array_diff(array_keys($params), array_keys($pnames)); |
1220 | $unset = array_diff(array_keys($params), array_keys($pnames)); |
1221 | $testp = array_flip($pnames); |
1221 | $testp = array_flip($pnames); |
1222 | foreach ($params as $i => $param) { |
1222 | foreach ($params as $i => $param) { |
1223 | if (!$param) { |
1223 | if (!$param) { |
1224 | $unset[] = $i; |
1224 | $unset[] = $i; |
1225 | continue; |
1225 | continue; |
1226 | }
|
1226 | }
|
1227 | if (!is_a($param, 'PEAR_Downloader_Package')) { |
1227 | if (!is_a($param, 'PEAR_Downloader_Package')) { |
1228 | $unset[] = $i; |
1228 | $unset[] = $i; |
1229 | continue; |
1229 | continue; |
1230 | }
|
1230 | }
|
1231 | if ($ignoreGroups) { |
1231 | if ($ignoreGroups) { |
1232 | $group = ''; |
1232 | $group = ''; |
1233 | } else { |
1233 | } else { |
1234 | $group = $param->getGroup(); |
1234 | $group = $param->getGroup(); |
1235 | }
|
1235 | }
|
1236 | if (!isset($testp[$param->getChannel() . '/' . $param->getPackage() . '-' . |
1236 | if (!isset($testp[$param->getChannel() . '/' . $param->getPackage() . '-' . |
1237 | $param->getVersion() . '#' . $group])) { |
1237 | $param->getVersion() . '#' . $group])) { |
1238 | $unset[] = $i; |
1238 | $unset[] = $i; |
1239 | }
|
1239 | }
|
1240 | }
|
1240 | }
|
1241 | foreach ($unset as $i) { |
1241 | foreach ($unset as $i) { |
1242 | unset($params[$i]); |
1242 | unset($params[$i]); |
1243 | }
|
1243 | }
|
1244 | $ret = array(); |
1244 | $ret = array(); |
1245 | foreach ($params as $i => $param) { |
1245 | foreach ($params as $i => $param) { |
1246 | $ret[] = &$params[$i]; |
1246 | $ret[] = &$params[$i]; |
1247 | }
|
1247 | }
|
1248 | $params = array(); |
1248 | $params = array(); |
1249 | foreach ($ret as $i => $param) { |
1249 | foreach ($ret as $i => $param) { |
1250 | $params[] = &$ret[$i]; |
1250 | $params[] = &$ret[$i]; |
1251 | }
|
1251 | }
|
1252 | }
|
1252 | }
|
1253 | 1253 | ||
1254 | function explicitState() |
1254 | function explicitState() |
1255 | {
|
1255 | {
|
1256 | return $this->_explicitState; |
1256 | return $this->_explicitState; |
1257 | }
|
1257 | }
|
1258 | 1258 | ||
1259 | function setExplicitState($s) |
1259 | function setExplicitState($s) |
1260 | {
|
1260 | {
|
1261 | $this->_explicitState = $s; |
1261 | $this->_explicitState = $s; |
1262 | }
|
1262 | }
|
1263 | 1263 | ||
1264 | /**
|
1264 | /**
|
1265 | * @static
|
1265 | * @static
|
1266 | */
|
1266 | */
|
1267 | function mergeDependencies(&$params) |
1267 | function mergeDependencies(&$params) |
1268 | {
|
1268 | {
|
1269 | $newparams = array(); |
1269 | $newparams = array(); |
1270 | $bundles = array(); |
1270 | $bundles = array(); |
1271 | foreach ($params as $i => $param) { |
1271 | foreach ($params as $i => $param) { |
1272 | if (!$param->isBundle()) { |
1272 | if (!$param->isBundle()) { |
1273 | continue; |
1273 | continue; |
1274 | }
|
1274 | }
|
1275 | $bundles[] = $i; |
1275 | $bundles[] = $i; |
1276 | $pf = &$param->getPackageFile(); |
1276 | $pf = &$param->getPackageFile(); |
1277 | $newdeps = array(); |
1277 | $newdeps = array(); |
1278 | $contents = $pf->getBundledPackages(); |
1278 | $contents = $pf->getBundledPackages(); |
1279 | if (!is_array($contents)) { |
1279 | if (!is_array($contents)) { |
1280 | $contents = array($contents); |
1280 | $contents = array($contents); |
1281 | }
|
1281 | }
|
1282 | foreach ($contents as $file) { |
1282 | foreach ($contents as $file) { |
1283 | $filecontents = $pf->getFileContents($file); |
1283 | $filecontents = $pf->getFileContents($file); |
1284 | $dl = &$param->getDownloader(); |
1284 | $dl = &$param->getDownloader(); |
1285 | $options = $dl->getOptions(); |
1285 | $options = $dl->getOptions(); |
1286 | if (PEAR::isError($dir = $dl->getDownloadDir())) { |
1286 | if (PEAR::isError($dir = $dl->getDownloadDir())) { |
1287 | return $dir; |
1287 | return $dir; |
1288 | }
|
1288 | }
|
1289 | $fp = @fopen($dir . DIRECTORY_SEPARATOR . $file, 'wb'); |
1289 | $fp = @fopen($dir . DIRECTORY_SEPARATOR . $file, 'wb'); |
1290 | if (!$fp) { |
1290 | if (!$fp) { |
1291 | continue; |
1291 | continue; |
1292 | }
|
1292 | }
|
1293 | fwrite($fp, $filecontents, strlen($filecontents)); |
1293 | fwrite($fp, $filecontents, strlen($filecontents)); |
1294 | fclose($fp); |
1294 | fclose($fp); |
1295 | if ($s = $params[$i]->explicitState()) { |
1295 | if ($s = $params[$i]->explicitState()) { |
1296 | $obj->setExplicitState($s); |
1296 | $obj->setExplicitState($s); |
1297 | }
|
1297 | }
|
1298 | $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader()); |
1298 | $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader()); |
1299 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1299 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1300 | if (PEAR::isError($dir = $dl->getDownloadDir())) { |
1300 | if (PEAR::isError($dir = $dl->getDownloadDir())) { |
1301 | PEAR::popErrorHandling(); |
1301 | PEAR::popErrorHandling(); |
1302 | return $dir; |
1302 | return $dir; |
1303 | }
|
1303 | }
|
1304 | $e = $obj->_fromFile($a = $dir . DIRECTORY_SEPARATOR . $file); |
1304 | $e = $obj->_fromFile($a = $dir . DIRECTORY_SEPARATOR . $file); |
1305 | PEAR::popErrorHandling(); |
1305 | PEAR::popErrorHandling(); |
1306 | if (PEAR::isError($e)) { |
1306 | if (PEAR::isError($e)) { |
1307 | if (!isset($options['soft'])) { |
1307 | if (!isset($options['soft'])) { |
1308 | $dl->log(0, $e->getMessage()); |
1308 | $dl->log(0, $e->getMessage()); |
1309 | }
|
1309 | }
|
1310 | continue; |
1310 | continue; |
1311 | }
|
1311 | }
|
1312 | $j = &$obj; |
1312 | $j = &$obj; |
1313 | if (!PEAR_Downloader_Package::willDownload($j, |
1313 | if (!PEAR_Downloader_Package::willDownload($j, |
1314 | array_merge($params, $newparams)) && !$param->isInstalled($j)) { |
1314 | array_merge($params, $newparams)) && !$param->isInstalled($j)) { |
1315 | $newparams[] = &$j; |
1315 | $newparams[] = &$j; |
1316 | }
|
1316 | }
|
1317 | }
|
1317 | }
|
1318 | }
|
1318 | }
|
1319 | foreach ($bundles as $i) { |
1319 | foreach ($bundles as $i) { |
1320 | unset($params[$i]); // remove bundles - only their contents matter for installation |
1320 | unset($params[$i]); // remove bundles - only their contents matter for installation |
1321 | }
|
1321 | }
|
1322 | PEAR_Downloader_Package::removeDuplicates($params); // strip any unset indices |
1322 | PEAR_Downloader_Package::removeDuplicates($params); // strip any unset indices |
1323 | if (count($newparams)) { // add in bundled packages for install |
1323 | if (count($newparams)) { // add in bundled packages for install |
1324 | foreach ($newparams as $i => $unused) { |
1324 | foreach ($newparams as $i => $unused) { |
1325 | $params[] = &$newparams[$i]; |
1325 | $params[] = &$newparams[$i]; |
1326 | }
|
1326 | }
|
1327 | $newparams = array(); |
1327 | $newparams = array(); |
1328 | }
|
1328 | }
|
1329 | foreach ($params as $i => $param) { |
1329 | foreach ($params as $i => $param) { |
1330 | $newdeps = array(); |
1330 | $newdeps = array(); |
1331 | foreach ($param->_downloadDeps as $dep) { |
1331 | foreach ($param->_downloadDeps as $dep) { |
1332 | if (!PEAR_Downloader_Package::willDownload($dep, |
1332 | if (!PEAR_Downloader_Package::willDownload($dep, |
1333 | array_merge($params, $newparams)) && !$param->isInstalled($dep)) { |
1333 | array_merge($params, $newparams)) && !$param->isInstalled($dep)) { |
1334 | $newdeps[] = $dep; |
1334 | $newdeps[] = $dep; |
1335 | } else { |
1335 | } else { |
1336 | // detect versioning conflicts here
|
1336 | // detect versioning conflicts here
|
1337 | }
|
1337 | }
|
1338 | }
|
1338 | }
|
1339 | // convert the dependencies into PEAR_Downloader_Package objects for the next time
|
1339 | // convert the dependencies into PEAR_Downloader_Package objects for the next time
|
1340 | // around
|
1340 | // around
|
1341 | $params[$i]->_downloadDeps = array(); |
1341 | $params[$i]->_downloadDeps = array(); |
1342 | foreach ($newdeps as $dep) { |
1342 | foreach ($newdeps as $dep) { |
1343 | $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader()); |
1343 | $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader()); |
1344 | if ($s = $params[$i]->explicitState()) { |
1344 | if ($s = $params[$i]->explicitState()) { |
1345 | $obj->setExplicitState($s); |
1345 | $obj->setExplicitState($s); |
1346 | }
|
1346 | }
|
1347 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1347 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1348 | $e = $obj->fromDepURL($dep); |
1348 | $e = $obj->fromDepURL($dep); |
1349 | PEAR::popErrorHandling(); |
1349 | PEAR::popErrorHandling(); |
1350 | if (PEAR::isError($e)) { |
1350 | if (PEAR::isError($e)) { |
1351 | if (!isset($options['soft'])) { |
1351 | if (!isset($options['soft'])) { |
1352 | $obj->_downloader->log(0, $e->getMessage()); |
1352 | $obj->_downloader->log(0, $e->getMessage()); |
1353 | }
|
1353 | }
|
1354 | continue; |
1354 | continue; |
1355 | }
|
1355 | }
|
1356 | $e = $obj->detectDependencies($params); |
1356 | $e = $obj->detectDependencies($params); |
1357 | if (PEAR::isError($e)) { |
1357 | if (PEAR::isError($e)) { |
1358 | if (!isset($options['soft'])) { |
1358 | if (!isset($options['soft'])) { |
1359 | $obj->_downloader->log(0, $e->getMessage()); |
1359 | $obj->_downloader->log(0, $e->getMessage()); |
1360 | }
|
1360 | }
|
1361 | }
|
1361 | }
|
1362 | $j = &$obj; |
1362 | $j = &$obj; |
1363 | $newparams[] = &$j; |
1363 | $newparams[] = &$j; |
1364 | }
|
1364 | }
|
1365 | }
|
1365 | }
|
1366 | if (count($newparams)) { |
1366 | if (count($newparams)) { |
1367 | foreach ($newparams as $i => $unused) { |
1367 | foreach ($newparams as $i => $unused) { |
1368 | $params[] = &$newparams[$i]; |
1368 | $params[] = &$newparams[$i]; |
1369 | }
|
1369 | }
|
1370 | return true; |
1370 | return true; |
1371 | } else { |
1371 | } else { |
1372 | return false; |
1372 | return false; |
1373 | }
|
1373 | }
|
1374 | }
|
1374 | }
|
1375 | 1375 | ||
1376 | 1376 | ||
1377 | /**
|
1377 | /**
|
1378 | * @static
|
1378 | * @static
|
1379 | */
|
1379 | */
|
1380 | function willDownload($param, $params) |
1380 | function willDownload($param, $params) |
1381 | {
|
1381 | {
|
1382 | if (!is_array($params)) { |
1382 | if (!is_array($params)) { |
1383 | return false; |
1383 | return false; |
1384 | }
|
1384 | }
|
1385 | foreach ($params as $obj) { |
1385 | foreach ($params as $obj) { |
1386 | if ($obj->isEqual($param)) { |
1386 | if ($obj->isEqual($param)) { |
1387 | return true; |
1387 | return true; |
1388 | }
|
1388 | }
|
1389 | }
|
1389 | }
|
1390 | return false; |
1390 | return false; |
1391 | }
|
1391 | }
|
1392 | 1392 | ||
1393 | /**
|
1393 | /**
|
1394 | * For simpler unit-testing
|
1394 | * For simpler unit-testing
|
1395 | * @param PEAR_Config
|
1395 | * @param PEAR_Config
|
1396 | * @param int
|
1396 | * @param int
|
1397 | * @param string
|
1397 | * @param string
|
1398 | */
|
1398 | */
|
1399 | function &getPackagefileObject(&$c, $d, $t = false) |
1399 | function &getPackagefileObject(&$c, $d, $t = false) |
1400 | {
|
1400 | {
|
1401 | $a = &new PEAR_PackageFile($c, $d, $t); |
1401 | $a = &new PEAR_PackageFile($c, $d, $t); |
1402 | return $a; |
1402 | return $a; |
1403 | }
|
1403 | }
|
1404 | 1404 | ||
1405 | 1405 | ||
1406 | /**
|
1406 | /**
|
1407 | * This will retrieve from a local file if possible, and parse out
|
1407 | * This will retrieve from a local file if possible, and parse out
|
1408 | * a group name as well. The original parameter will be modified to reflect this.
|
1408 | * a group name as well. The original parameter will be modified to reflect this.
|
1409 | * @param string|array can be a parsed package name as well
|
1409 | * @param string|array can be a parsed package name as well
|
1410 | * @access private
|
1410 | * @access private
|
1411 | */
|
1411 | */
|
1412 | function _fromFile(&$param) |
1412 | function _fromFile(&$param) |
1413 | {
|
1413 | {
|
1414 | $saveparam = $param; |
1414 | $saveparam = $param; |
1415 | if (is_string($param)) { |
1415 | if (is_string($param)) { |
1416 | if (!@file_exists($param)) { |
1416 | if (!@file_exists($param)) { |
1417 | $test = explode('#', $param); |
1417 | $test = explode('#', $param); |
1418 | $group = array_pop($test); |
1418 | $group = array_pop($test); |
1419 | if (@file_exists(implode('#', $test))) { |
1419 | if (@file_exists(implode('#', $test))) { |
1420 | $this->setGroup($group); |
1420 | $this->setGroup($group); |
1421 | $param = implode('#', $test); |
1421 | $param = implode('#', $test); |
1422 | $this->_explicitGroup = true; |
1422 | $this->_explicitGroup = true; |
1423 | }
|
1423 | }
|
1424 | }
|
1424 | }
|
1425 | if (@is_file($param)) { |
1425 | if (@is_file($param)) { |
1426 | $this->_type = 'local'; |
1426 | $this->_type = 'local'; |
1427 | $options = $this->_downloader->getOptions(); |
1427 | $options = $this->_downloader->getOptions(); |
1428 | if (isset($options['downloadonly'])) { |
1428 | if (isset($options['downloadonly'])) { |
1429 | $pkg = &$this->getPackagefileObject($this->_config, |
1429 | $pkg = &$this->getPackagefileObject($this->_config, |
1430 | $this->_downloader->_debug); |
1430 | $this->_downloader->_debug); |
1431 | } else { |
1431 | } else { |
1432 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1432 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1433 | return $dir; |
1433 | return $dir; |
1434 | }
|
1434 | }
|
1435 | $pkg = &$this->getPackagefileObject($this->_config, |
1435 | $pkg = &$this->getPackagefileObject($this->_config, |
1436 | $this->_downloader->_debug, $dir); |
1436 | $this->_downloader->_debug, $dir); |
1437 | }
|
1437 | }
|
1438 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1438 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1439 | $pf = &$pkg->fromAnyFile($param, PEAR_VALIDATE_INSTALLING); |
1439 | $pf = &$pkg->fromAnyFile($param, PEAR_VALIDATE_INSTALLING); |
1440 | PEAR::popErrorHandling(); |
1440 | PEAR::popErrorHandling(); |
1441 | if (PEAR::isError($pf)) { |
1441 | if (PEAR::isError($pf)) { |
1442 | $this->_valid = false; |
1442 | $this->_valid = false; |
1443 | $param = $saveparam; |
1443 | $param = $saveparam; |
1444 | return $pf; |
1444 | return $pf; |
1445 | }
|
1445 | }
|
1446 | $this->_packagefile = &$pf; |
1446 | $this->_packagefile = &$pf; |
1447 | if (!$this->getGroup()) { |
1447 | if (!$this->getGroup()) { |
1448 | $this->setGroup('default'); // install the default dependency group |
1448 | $this->setGroup('default'); // install the default dependency group |
1449 | }
|
1449 | }
|
1450 | return $this->_valid = true; |
1450 | return $this->_valid = true; |
1451 | }
|
1451 | }
|
1452 | }
|
1452 | }
|
1453 | $param = $saveparam; |
1453 | $param = $saveparam; |
1454 | return $this->_valid = false; |
1454 | return $this->_valid = false; |
1455 | }
|
1455 | }
|
1456 | 1456 | ||
1457 | function _fromUrl($param, $saveparam = '') |
1457 | function _fromUrl($param, $saveparam = '') |
1458 | {
|
1458 | {
|
1459 | if (!is_array($param) && |
1459 | if (!is_array($param) && |
1460 | (preg_match('#^(http|ftp)://#', $param))) { |
1460 | (preg_match('#^(http|ftp)://#', $param))) { |
1461 | $options = $this->_downloader->getOptions(); |
1461 | $options = $this->_downloader->getOptions(); |
1462 | $this->_type = 'url'; |
1462 | $this->_type = 'url'; |
1463 | $callback = $this->_downloader->ui ? |
1463 | $callback = $this->_downloader->ui ? |
1464 | array(&$this->_downloader, '_downloadCallback') : null; |
1464 | array(&$this->_downloader, '_downloadCallback') : null; |
1465 | $this->_downloader->pushErrorHandling(PEAR_ERROR_RETURN); |
1465 | $this->_downloader->pushErrorHandling(PEAR_ERROR_RETURN); |
1466 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1466 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1467 | $this->_downloader->popErrorHandling(); |
1467 | $this->_downloader->popErrorHandling(); |
1468 | return $dir; |
1468 | return $dir; |
1469 | }
|
1469 | }
|
1470 | $this->_downloader->log(3, 'Downloading "' . $param . '"'); |
1470 | $this->_downloader->log(3, 'Downloading "' . $param . '"'); |
1471 | $file = $this->_downloader->downloadHttp($param, $this->_downloader->ui, |
1471 | $file = $this->_downloader->downloadHttp($param, $this->_downloader->ui, |
1472 | $dir, $callback, null, false, $this->getChannel()); |
1472 | $dir, $callback, null, false, $this->getChannel()); |
1473 | $this->_downloader->popErrorHandling(); |
1473 | $this->_downloader->popErrorHandling(); |
1474 | if (PEAR::isError($file)) { |
1474 | if (PEAR::isError($file)) { |
1475 | if (!empty($saveparam)) { |
1475 | if (!empty($saveparam)) { |
1476 | $saveparam = ", cannot download \"$saveparam\""; |
1476 | $saveparam = ", cannot download \"$saveparam\""; |
1477 | }
|
1477 | }
|
1478 | $err = PEAR::raiseError('Could not download from "' . $param . |
1478 | $err = PEAR::raiseError('Could not download from "' . $param . |
1479 | '"' . $saveparam . ' (' . $file->getMessage() . ')'); |
1479 | '"' . $saveparam . ' (' . $file->getMessage() . ')'); |
1480 | return $err; |
1480 | return $err; |
1481 | }
|
1481 | }
|
1482 | if ($this->_rawpackagefile) { |
1482 | if ($this->_rawpackagefile) { |
1483 | require_once 'Archive/Tar.php'; |
1483 | require_once 'Archive/Tar.php'; |
1484 | $tar = &new Archive_Tar($file); |
1484 | $tar = &new Archive_Tar($file); |
1485 | $packagexml = $tar->extractInString('package2.xml'); |
1485 | $packagexml = $tar->extractInString('package2.xml'); |
1486 | if (!$packagexml) { |
1486 | if (!$packagexml) { |
1487 | $packagexml = $tar->extractInString('package.xml'); |
1487 | $packagexml = $tar->extractInString('package.xml'); |
1488 | }
|
1488 | }
|
1489 | if (str_replace(array("\n", "\r"), array('',''), $packagexml) != |
1489 | if (str_replace(array("\n", "\r"), array('',''), $packagexml) != |
1490 | str_replace(array("\n", "\r"), array('',''), $this->_rawpackagefile)) { |
1490 | str_replace(array("\n", "\r"), array('',''), $this->_rawpackagefile)) { |
1491 | if ($this->getChannel() == 'pear.php.net') { |
1491 | if ($this->getChannel() == 'pear.php.net') { |
1492 | // be more lax for the existing PEAR packages that have not-ok
|
1492 | // be more lax for the existing PEAR packages that have not-ok
|
1493 | // characters in their package.xml
|
1493 | // characters in their package.xml
|
1494 | $this->_downloader->log(0, 'CRITICAL WARNING: The "' . |
1494 | $this->_downloader->log(0, 'CRITICAL WARNING: The "' . |
1495 | $this->getPackage() . '" package has invalid characters in its ' . |
1495 | $this->getPackage() . '" package has invalid characters in its ' . |
1496 | 'package.xml. The next version of PEAR may not be able to install ' . |
1496 | 'package.xml. The next version of PEAR may not be able to install ' . |
1497 | 'this package for security reasons. Please open a bug report at ' . |
1497 | 'this package for security reasons. Please open a bug report at ' . |
1498 | 'http://pear.php.net/package/' . $this->getPackage() . '/bugs'); |
1498 | 'http://pear.php.net/package/' . $this->getPackage() . '/bugs'); |
1499 | } else { |
1499 | } else { |
1500 | return PEAR::raiseError('CRITICAL ERROR: package.xml downloaded does ' . |
1500 | return PEAR::raiseError('CRITICAL ERROR: package.xml downloaded does ' . |
1501 | 'not match value returned from xml-rpc'); |
1501 | 'not match value returned from xml-rpc'); |
1502 | }
|
1502 | }
|
1503 | }
|
1503 | }
|
1504 | }
|
1504 | }
|
1505 | // whew, download worked!
|
1505 | // whew, download worked!
|
1506 | if (isset($options['downloadonly'])) { |
1506 | if (isset($options['downloadonly'])) { |
1507 | $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug); |
1507 | $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug); |
1508 | } else { |
1508 | } else { |
1509 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1509 | if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) { |
1510 | return $dir; |
1510 | return $dir; |
1511 | }
|
1511 | }
|
1512 | $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug, |
1512 | $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug, |
1513 | $dir); |
1513 | $dir); |
1514 | }
|
1514 | }
|
1515 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1515 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1516 | $pf = &$pkg->fromAnyFile($file, PEAR_VALIDATE_INSTALLING); |
1516 | $pf = &$pkg->fromAnyFile($file, PEAR_VALIDATE_INSTALLING); |
1517 | PEAR::popErrorHandling(); |
1517 | PEAR::popErrorHandling(); |
1518 | if (PEAR::isError($pf)) { |
1518 | if (PEAR::isError($pf)) { |
1519 | if (is_array($pf->getUserInfo())) { |
1519 | if (is_array($pf->getUserInfo())) { |
1520 | foreach ($pf->getUserInfo() as $err) { |
1520 | foreach ($pf->getUserInfo() as $err) { |
1521 | if (is_array($err)) { |
1521 | if (is_array($err)) { |
1522 | $err = $err['message']; |
1522 | $err = $err['message']; |
1523 | }
|
1523 | }
|
1524 | if (!isset($options['soft'])) { |
1524 | if (!isset($options['soft'])) { |
1525 | $this->_downloader->log(0, "Validation Error: $err"); |
1525 | $this->_downloader->log(0, "Validation Error: $err"); |
1526 | }
|
1526 | }
|
1527 | }
|
1527 | }
|
1528 | }
|
1528 | }
|
1529 | if (!isset($options['soft'])) { |
1529 | if (!isset($options['soft'])) { |
1530 | $this->_downloader->log(0, $pf->getMessage()); |
1530 | $this->_downloader->log(0, $pf->getMessage()); |
1531 | }
|
1531 | }
|
1532 | $err = PEAR::raiseError('Download of "' . ($saveparam ? $saveparam : |
1532 | $err = PEAR::raiseError('Download of "' . ($saveparam ? $saveparam : |
1533 | $param) . '" succeeded, but it is not a valid package archive'); |
1533 | $param) . '" succeeded, but it is not a valid package archive'); |
1534 | $this->_valid = false; |
1534 | $this->_valid = false; |
1535 | return $err; |
1535 | return $err; |
1536 | }
|
1536 | }
|
1537 | $this->_packagefile = &$pf; |
1537 | $this->_packagefile = &$pf; |
1538 | $this->setGroup('default'); // install the default dependency group |
1538 | $this->setGroup('default'); // install the default dependency group |
1539 | return $this->_valid = true; |
1539 | return $this->_valid = true; |
1540 | }
|
1540 | }
|
1541 | return $this->_valid = false; |
1541 | return $this->_valid = false; |
1542 | }
|
1542 | }
|
1543 | 1543 | ||
1544 | /**
|
1544 | /**
|
1545 | *
|
1545 | *
|
1546 | * @param string|array pass in an array of format
|
1546 | * @param string|array pass in an array of format
|
1547 | * array(
|
1547 | * array(
|
1548 | * 'package' => 'pname',
|
1548 | * 'package' => 'pname',
|
1549 | * ['channel' => 'channame',]
|
1549 | * ['channel' => 'channame',]
|
1550 | * ['version' => 'version',]
|
1550 | * ['version' => 'version',]
|
1551 | * ['state' => 'state',])
|
1551 | * ['state' => 'state',])
|
1552 | * or a string of format [channame/]pname[-version|-state]
|
1552 | * or a string of format [channame/]pname[-version|-state]
|
1553 | */
|
1553 | */
|
1554 | function _fromString($param) |
1554 | function _fromString($param) |
1555 | {
|
1555 | {
|
1556 | $options = $this->_downloader->getOptions(); |
1556 | $options = $this->_downloader->getOptions(); |
1557 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1557 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1558 | $pname = $this->_registry->parsePackageName($param, |
1558 | $pname = $this->_registry->parsePackageName($param, |
1559 | $this->_config->get('default_channel')); |
1559 | $this->_config->get('default_channel')); |
1560 | PEAR::popErrorHandling(); |
1560 | PEAR::popErrorHandling(); |
1561 | if (PEAR::isError($pname)) { |
1561 | if (PEAR::isError($pname)) { |
1562 | if ($pname->getCode() == 'invalid') { |
1562 | if ($pname->getCode() == 'invalid') { |
1563 | $this->_valid = false; |
1563 | $this->_valid = false; |
1564 | return false; |
1564 | return false; |
1565 | }
|
1565 | }
|
1566 | if ($pname->getCode() == 'channel') { |
1566 | if ($pname->getCode() == 'channel') { |
1567 | $parsed = $pname->getUserInfo(); |
1567 | $parsed = $pname->getUserInfo(); |
1568 | if ($this->_downloader->discover($parsed['channel'])) { |
1568 | if ($this->_downloader->discover($parsed['channel'])) { |
1569 | if ($this->_config->get('auto_discover')) { |
1569 | if ($this->_config->get('auto_discover')) { |
1570 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1570 | PEAR::pushErrorHandling(PEAR_ERROR_RETURN); |
1571 | $pname = $this->_registry->parsePackageName($param, |
1571 | $pname = $this->_registry->parsePackageName($param, |
1572 | $this->_config->get('default_channel')); |
1572 | $this->_config->get('default_channel')); |
1573 | PEAR::popErrorHandling(); |
1573 | PEAR::popErrorHandling(); |
1574 | } else { |
1574 | } else { |
1575 | if (!isset($options['soft'])) { |
1575 | if (!isset($options['soft'])) { |
1576 | $this->_downloader->log(0, 'Channel "' . $parsed['channel'] . |
1576 | $this->_downloader->log(0, 'Channel "' . $parsed['channel'] . |
1577 | '" is not initialized, use ' . |
1577 | '" is not initialized, use ' . |
1578 | '"pear channel-discover ' . $parsed['channel'] . '" to initialize' . |
1578 | '"pear channel-discover ' . $parsed['channel'] . '" to initialize' . |
1579 | 'or pear config-set auto_discover 1'); |
1579 | 'or pear config-set auto_discover 1'); |
1580 | }
|
1580 | }
|
1581 | }
|
1581 | }
|
1582 | }
|
1582 | }
|
1583 | if (PEAR::isError($pname)) { |
1583 | if (PEAR::isError($pname)) { |
1584 | if (!isset($options['soft'])) { |
1584 | if (!isset($options['soft'])) { |
1585 | $this->_downloader->log(0, $pname->getMessage()); |
1585 | $this->_downloader->log(0, $pname->getMessage()); |
1586 | }
|
1586 | }
|
1587 | if (is_array($param)) { |
1587 | if (is_array($param)) { |
1588 | $param = $this->_registry->parsedPackageNameToString($param); |
1588 | $param = $this->_registry->parsedPackageNameToString($param); |
1589 | }
|
1589 | }
|
1590 | $err = PEAR::raiseError('invalid package name/package file "' . |
1590 | $err = PEAR::raiseError('invalid package name/package file "' . |
1591 | $param . '"'); |
1591 | $param . '"'); |
1592 | $this->_valid = false; |
1592 | $this->_valid = false; |
1593 | return $err; |
1593 | return $err; |
1594 | }
|
1594 | }
|
1595 | } else { |
1595 | } else { |
1596 | if (!isset($options['soft'])) { |
1596 | if (!isset($options['soft'])) { |
1597 | $this->_downloader->log(0, $pname->getMessage()); |
1597 | $this->_downloader->log(0, $pname->getMessage()); |
1598 | }
|
1598 | }
|
1599 | $err = PEAR::raiseError('invalid package name/package file "' . |
1599 | $err = PEAR::raiseError('invalid package name/package file "' . |
1600 | $param . '"'); |
1600 | $param . '"'); |
1601 | $this->_valid = false; |
1601 | $this->_valid = false; |
1602 | return $err; |
1602 | return $err; |
1603 | }
|
1603 | }
|
1604 | }
|
1604 | }
|
1605 | if (!isset($this->_type)) { |
1605 | if (!isset($this->_type)) { |
1606 | $this->_type = 'xmlrpc'; |
1606 | $this->_type = 'xmlrpc'; |
1607 | }
|
1607 | }
|
1608 | $this->_parsedname = $pname; |
1608 | $this->_parsedname = $pname; |
1609 | if (isset($pname['state'])) { |
1609 | if (isset($pname['state'])) { |
1610 | $this->_explicitState = $pname['state']; |
1610 | $this->_explicitState = $pname['state']; |
1611 | } else { |
1611 | } else { |
1612 | $this->_explicitState = false; |
1612 | $this->_explicitState = false; |
1613 | }
|
1613 | }
|
1614 | if (isset($pname['group'])) { |
1614 | if (isset($pname['group'])) { |
1615 | $this->_explicitGroup = true; |
1615 | $this->_explicitGroup = true; |
1616 | } else { |
1616 | } else { |
1617 | $this->_explicitGroup = false; |
1617 | $this->_explicitGroup = false; |
1618 | }
|
1618 | }
|
1619 | $info = $this->_downloader->_getPackageDownloadUrl($pname); |
1619 | $info = $this->_downloader->_getPackageDownloadUrl($pname); |
1620 | if (PEAR::isError($info)) { |
1620 | if (PEAR::isError($info)) { |
1621 | if ($info->getCode() != -976 && $pname['channel'] == 'pear.php.net') { |
1621 | if ($info->getCode() != -976 && $pname['channel'] == 'pear.php.net') { |
1622 | // try pecl
|
1622 | // try pecl
|
1623 | $pname['channel'] = 'pecl.php.net'; |
1623 | $pname['channel'] = 'pecl.php.net'; |
1624 | if ($test = $this->_downloader->_getPackageDownloadUrl($pname)) { |
1624 | if ($test = $this->_downloader->_getPackageDownloadUrl($pname)) { |
1625 | if (!PEAR::isError($test)) { |
1625 | if (!PEAR::isError($test)) { |
1626 | $info = PEAR::raiseError($info->getMessage() . ' - package ' . |
1626 | $info = PEAR::raiseError($info->getMessage() . ' - package ' . |
1627 | $this->_registry->parsedPackageNameToString($pname, true) . |
1627 | $this->_registry->parsedPackageNameToString($pname, true) . |
1628 | ' can be installed with "pecl install ' . $pname['package'] . |
1628 | ' can be installed with "pecl install ' . $pname['package'] . |
1629 | '"'); |
1629 | '"'); |
1630 | } else { |
1630 | } else { |
1631 | $pname['channel'] = 'pear.php.net'; |
1631 | $pname['channel'] = 'pear.php.net'; |
1632 | }
|
1632 | }
|
1633 | } else { |
1633 | } else { |
1634 | $pname['channel'] = 'pear.php.net'; |
1634 | $pname['channel'] = 'pear.php.net'; |
1635 | }
|
1635 | }
|
1636 | }
|
1636 | }
|
1637 | return $info; |
1637 | return $info; |
1638 | }
|
1638 | }
|
1639 | $this->_rawpackagefile = $info['raw']; |
1639 | $this->_rawpackagefile = $info['raw']; |
1640 | $ret = $this->_analyzeDownloadURL($info, $param, $pname); |
1640 | $ret = $this->_analyzeDownloadURL($info, $param, $pname); |
1641 | if (PEAR::isError($ret)) { |
1641 | if (PEAR::isError($ret)) { |
1642 | return $ret; |
1642 | return $ret; |
1643 | }
|
1643 | }
|
1644 | if ($ret) { |
1644 | if ($ret) { |
1645 | $this->_downloadURL = $ret; |
1645 | $this->_downloadURL = $ret; |
1646 | return $this->_valid = (bool) $ret; |
1646 | return $this->_valid = (bool) $ret; |
1647 | }
|
1647 | }
|
1648 | }
|
1648 | }
|
1649 | 1649 | ||
1650 | /**
|
1650 | /**
|
1651 | * @param array output of package.getDownloadURL
|
1651 | * @param array output of package.getDownloadURL
|
1652 | * @param string|array|object information for detecting packages to be downloaded, and
|
1652 | * @param string|array|object information for detecting packages to be downloaded, and
|
1653 | * for errors
|
1653 | * for errors
|
1654 | * @param array name information of the package
|
1654 | * @param array name information of the package
|
1655 | * @param array|null packages to be downloaded
|
1655 | * @param array|null packages to be downloaded
|
1656 | * @param bool is this an optional dependency?
|
1656 | * @param bool is this an optional dependency?
|
1657 | * @param bool is this any kind of dependency?
|
1657 | * @param bool is this any kind of dependency?
|
1658 | * @access private
|
1658 | * @access private
|
1659 | */
|
1659 | */
|
1660 | function _analyzeDownloadURL($info, $param, $pname, $params = null, $optional = false, |
1660 | function _analyzeDownloadURL($info, $param, $pname, $params = null, $optional = false, |
1661 | $isdependency = false) |
1661 | $isdependency = false) |
1662 | {
|
1662 | {
|
1663 | if (!is_string($param) && PEAR_Downloader_Package::willDownload($param, $params)) { |
1663 | if (!is_string($param) && PEAR_Downloader_Package::willDownload($param, $params)) { |
1664 | return false; |
1664 | return false; |
1665 | }
|
1665 | }
|
1666 | if (!$info) { |
1666 | if (!$info) { |
1667 | if (!is_string($param)) { |
1667 | if (!is_string($param)) { |
1668 | $saveparam = ", cannot download \"$param\""; |
1668 | $saveparam = ", cannot download \"$param\""; |
1669 | } else { |
1669 | } else { |
1670 | $saveparam = ''; |
1670 | $saveparam = ''; |
1671 | }
|
1671 | }
|
1672 | // no releases exist
|
1672 | // no releases exist
|
1673 | return PEAR::raiseError('No releases for package "' . |
1673 | return PEAR::raiseError('No releases for package "' . |
1674 | $this->_registry->parsedPackageNameToString($pname, true) . '" exist' . $saveparam); |
1674 | $this->_registry->parsedPackageNameToString($pname, true) . '" exist' . $saveparam); |
1675 | }
|
1675 | }
|
1676 | if (strtolower($info['info']->getChannel()) != strtolower($pname['channel'])) { |
1676 | if (strtolower($info['info']->getChannel()) != strtolower($pname['channel'])) { |
1677 | $err = false; |
1677 | $err = false; |
1678 | if ($pname['channel'] == 'pecl.php.net') { |
1678 | if ($pname['channel'] == 'pecl.php.net') { |
1679 | if ($info['info']->getChannel() != 'pear.php.net') { |
1679 | if ($info['info']->getChannel() != 'pear.php.net') { |
1680 | $err = true; |
1680 | $err = true; |
1681 | }
|
1681 | }
|
1682 | } elseif ($info['info']->getChannel() == 'pecl.php.net') { |
1682 | } elseif ($info['info']->getChannel() == 'pecl.php.net') { |
1683 | if ($pname['channel'] != 'pear.php.net') { |
1683 | if ($pname['channel'] != 'pear.php.net') { |
1684 | $err = true; |
1684 | $err = true; |
1685 | }
|
1685 | }
|
1686 | } else { |
1686 | } else { |
1687 | $err = true; |
1687 | $err = true; |
1688 | }
|
1688 | }
|
1689 | if ($err) { |
1689 | if ($err) { |
1690 | return PEAR::raiseError('SECURITY ERROR: package in channel "' . $pname['channel'] . |
1690 | return PEAR::raiseError('SECURITY ERROR: package in channel "' . $pname['channel'] . |
1691 | '" retrieved another channel\'s name for download! ("' . |
1691 | '" retrieved another channel\'s name for download! ("' . |
1692 | $info['info']->getChannel() . '")'); |
1692 | $info['info']->getChannel() . '")'); |
1693 | }
|
1693 | }
|
1694 | }
|
1694 | }
|
1695 | if (!isset($info['url'])) { |
1695 | if (!isset($info['url'])) { |
1696 | if ($this->isInstalled($info)) { |
1696 | if ($this->isInstalled($info)) { |
1697 | if ($isdependency && version_compare($info['version'], |
1697 | if ($isdependency && version_compare($info['version'], |
1698 | $this->_registry->packageInfo($info['info']->getPackage(), |
1698 | $this->_registry->packageInfo($info['info']->getPackage(), |
1699 | 'version', $info['info']->getChannel()), '<=')) { |
1699 | 'version', $info['info']->getChannel()), '<=')) { |
1700 | // ignore bogus errors of "failed to download dependency"
|
1700 | // ignore bogus errors of "failed to download dependency"
|
1701 | // if it is already installed and the one that would be
|
1701 | // if it is already installed and the one that would be
|
1702 | // downloaded is older or the same version (Bug #7219)
|
1702 | // downloaded is older or the same version (Bug #7219)
|
1703 | return false; |
1703 | return false; |
1704 | }
|
1704 | }
|
1705 | }
|
1705 | }
|
1706 | $instead = ', will instead download version ' . $info['version'] . |
1706 | $instead = ', will instead download version ' . $info['version'] . |
1707 | ', stability "' . $info['info']->getState() . '"'; |
1707 | ', stability "' . $info['info']->getState() . '"'; |
1708 | // releases exist, but we failed to get any
|
1708 | // releases exist, but we failed to get any
|
1709 | if (isset($this->_downloader->_options['force'])) { |
1709 | if (isset($this->_downloader->_options['force'])) { |
1710 | if (isset($pname['version'])) { |
1710 | if (isset($pname['version'])) { |
1711 | $vs = ', version "' . $pname['version'] . '"'; |
1711 | $vs = ', version "' . $pname['version'] . '"'; |
1712 | } elseif (isset($pname['state'])) { |
1712 | } elseif (isset($pname['state'])) { |
1713 | $vs = ', stability "' . $pname['state'] . '"'; |
1713 | $vs = ', stability "' . $pname['state'] . '"'; |
1714 | } elseif ($param == 'dependency') { |
1714 | } elseif ($param == 'dependency') { |
1715 | if (!class_exists('PEAR_Common')) { |
1715 | if (!class_exists('PEAR_Common')) { |
1716 | require_once 'PEAR/Common.php'; |
1716 | require_once 'PEAR/Common.php'; |
1717 | }
|
1717 | }
|
1718 | if (!in_array($info['info']->getState(), |
1718 | if (!in_array($info['info']->getState(), |
1719 | PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) { |
1719 | PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) { |
1720 | if ($optional) { |
1720 | if ($optional) { |
1721 | // don't spit out confusing error message
|
1721 | // don't spit out confusing error message
|
1722 | return $this->_downloader->_getPackageDownloadUrl( |
1722 | return $this->_downloader->_getPackageDownloadUrl( |
1723 | array('package' => $pname['package'], |
1723 | array('package' => $pname['package'], |
1724 | 'channel' => $pname['channel'], |
1724 | 'channel' => $pname['channel'], |
1725 | 'version' => $info['version'])); |
1725 | 'version' => $info['version'])); |
1726 | }
|
1726 | }
|
1727 | $vs = ' within preferred state "' . $this->_config->get('preferred_state') . |
1727 | $vs = ' within preferred state "' . $this->_config->get('preferred_state') . |
1728 | '"'; |
1728 | '"'; |
1729 | } else { |
1729 | } else { |
1730 | if (!class_exists('PEAR_Dependency2')) { |
1730 | if (!class_exists('PEAR_Dependency2')) { |
1731 | require_once 'PEAR/Dependency2.php'; |
1731 | require_once 'PEAR/Dependency2.php'; |
1732 | }
|
1732 | }
|
1733 | if ($optional) { |
1733 | if ($optional) { |
1734 | // don't spit out confusing error message
|
1734 | // don't spit out confusing error message
|
1735 | return $this->_downloader->_getPackageDownloadUrl( |
1735 | return $this->_downloader->_getPackageDownloadUrl( |
1736 | array('package' => $pname['package'], |
1736 | array('package' => $pname['package'], |
1737 | 'channel' => $pname['channel'], |
1737 | 'channel' => $pname['channel'], |
1738 | 'version' => $info['version'])); |
1738 | 'version' => $info['version'])); |
1739 | }
|
1739 | }
|
1740 | $vs = PEAR_Dependency2::_getExtraString($pname); |
1740 | $vs = PEAR_Dependency2::_getExtraString($pname); |
1741 | $instead = ''; |
1741 | $instead = ''; |
1742 | }
|
1742 | }
|
1743 | } else { |
1743 | } else { |
1744 | $vs = ' within preferred state "' . $this->_config->get( |
1744 | $vs = ' within preferred state "' . $this->_config->get( |
1745 | 'preferred_state') . '"'; |
1745 | 'preferred_state') . '"'; |
1746 | }
|
1746 | }
|
1747 | if (!isset($options['soft'])) { |
1747 | if (!isset($options['soft'])) { |
1748 | $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] . |
1748 | $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] . |
1749 | '/' . $pname['package'] . $vs . $instead); |
1749 | '/' . $pname['package'] . $vs . $instead); |
1750 | }
|
1750 | }
|
1751 | // download the latest release
|
1751 | // download the latest release
|
1752 | return $this->_downloader->_getPackageDownloadUrl( |
1752 | return $this->_downloader->_getPackageDownloadUrl( |
1753 | array('package' => $pname['package'], |
1753 | array('package' => $pname['package'], |
1754 | 'channel' => $pname['channel'], |
1754 | 'channel' => $pname['channel'], |
1755 | 'version' => $info['version'])); |
1755 | 'version' => $info['version'])); |
1756 | } else { |
1756 | } else { |
1757 | if (isset($info['php']) && $info['php']) { |
1757 | if (isset($info['php']) && $info['php']) { |
1758 | $err = PEAR::raiseError('Failed to download ' . |
1758 | $err = PEAR::raiseError('Failed to download ' . |
1759 | $this->_registry->parsedPackageNameToString( |
1759 | $this->_registry->parsedPackageNameToString( |
1760 | array('channel' => $pname['channel'], |
1760 | array('channel' => $pname['channel'], |
1761 | 'package' => $pname['package']), |
1761 | 'package' => $pname['package']), |
1762 | true) . |
1762 | true) . |
1763 | ', latest release is version ' . $info['php']['v'] . |
1763 | ', latest release is version ' . $info['php']['v'] . |
1764 | ', but it requires PHP version "' . |
1764 | ', but it requires PHP version "' . |
1765 | $info['php']['m'] . '", use "' . |
1765 | $info['php']['m'] . '", use "' . |
1766 | $this->_registry->parsedPackageNameToString( |
1766 | $this->_registry->parsedPackageNameToString( |
1767 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1767 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1768 | 'version' => $info['php']['v'])) . '" to install', |
1768 | 'version' => $info['php']['v'])) . '" to install', |
1769 | PEAR_DOWNLOADER_PACKAGE_PHPVERSION); |
1769 | PEAR_DOWNLOADER_PACKAGE_PHPVERSION); |
1770 | return $err; |
1770 | return $err; |
1771 | }
|
1771 | }
|
1772 | // construct helpful error message
|
1772 | // construct helpful error message
|
1773 | if (isset($pname['version'])) { |
1773 | if (isset($pname['version'])) { |
1774 | $vs = ', version "' . $pname['version'] . '"'; |
1774 | $vs = ', version "' . $pname['version'] . '"'; |
1775 | } elseif (isset($pname['state'])) { |
1775 | } elseif (isset($pname['state'])) { |
1776 | $vs = ', stability "' . $pname['state'] . '"'; |
1776 | $vs = ', stability "' . $pname['state'] . '"'; |
1777 | } elseif ($param == 'dependency') { |
1777 | } elseif ($param == 'dependency') { |
1778 | if (!class_exists('PEAR_Common')) { |
1778 | if (!class_exists('PEAR_Common')) { |
1779 | require_once 'PEAR/Common.php'; |
1779 | require_once 'PEAR/Common.php'; |
1780 | }
|
1780 | }
|
1781 | if (!in_array($info['info']->getState(), |
1781 | if (!in_array($info['info']->getState(), |
1782 | PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) { |
1782 | PEAR_Common::betterStates($this->_config->get('preferred_state'), true))) { |
1783 | if ($optional) { |
1783 | if ($optional) { |
1784 | // don't spit out confusing error message, and don't die on
|
1784 | // don't spit out confusing error message, and don't die on
|
1785 | // optional dep failure!
|
1785 | // optional dep failure!
|
1786 | return $this->_downloader->_getPackageDownloadUrl( |
1786 | return $this->_downloader->_getPackageDownloadUrl( |
1787 | array('package' => $pname['package'], |
1787 | array('package' => $pname['package'], |
1788 | 'channel' => $pname['channel'], |
1788 | 'channel' => $pname['channel'], |
1789 | 'version' => $info['version'])); |
1789 | 'version' => $info['version'])); |
1790 | }
|
1790 | }
|
1791 | $vs = ' within preferred state "' . $this->_config->get('preferred_state') . |
1791 | $vs = ' within preferred state "' . $this->_config->get('preferred_state') . |
1792 | '"'; |
1792 | '"'; |
1793 | } else { |
1793 | } else { |
1794 | if (!class_exists('PEAR_Dependency2')) { |
1794 | if (!class_exists('PEAR_Dependency2')) { |
1795 | require_once 'PEAR/Dependency2.php'; |
1795 | require_once 'PEAR/Dependency2.php'; |
1796 | }
|
1796 | }
|
1797 | if ($optional) { |
1797 | if ($optional) { |
1798 | // don't spit out confusing error message, and don't die on
|
1798 | // don't spit out confusing error message, and don't die on
|
1799 | // optional dep failure!
|
1799 | // optional dep failure!
|
1800 | return $this->_downloader->_getPackageDownloadUrl( |
1800 | return $this->_downloader->_getPackageDownloadUrl( |
1801 | array('package' => $pname['package'], |
1801 | array('package' => $pname['package'], |
1802 | 'channel' => $pname['channel'], |
1802 | 'channel' => $pname['channel'], |
1803 | 'version' => $info['version'])); |
1803 | 'version' => $info['version'])); |
1804 | }
|
1804 | }
|
1805 | $vs = PEAR_Dependency2::_getExtraString($pname); |
1805 | $vs = PEAR_Dependency2::_getExtraString($pname); |
1806 | }
|
1806 | }
|
1807 | } else { |
1807 | } else { |
1808 | $vs = ' within preferred state "' . $this->_downloader->config->get( |
1808 | $vs = ' within preferred state "' . $this->_downloader->config->get( |
1809 | 'preferred_state') . '"'; |
1809 | 'preferred_state') . '"'; |
1810 | }
|
1810 | }
|
1811 | $options = $this->_downloader->getOptions(); |
1811 | $options = $this->_downloader->getOptions(); |
1812 | // this is only set by the "download-all" command
|
1812 | // this is only set by the "download-all" command
|
1813 | if (isset($options['ignorepreferred_state'])) { |
1813 | if (isset($options['ignorepreferred_state'])) { |
1814 | $err = PEAR::raiseError( |
1814 | $err = PEAR::raiseError( |
1815 | 'Failed to download ' . $this->_registry->parsedPackageNameToString( |
1815 | 'Failed to download ' . $this->_registry->parsedPackageNameToString( |
1816 | array('channel' => $pname['channel'], 'package' => $pname['package']), |
1816 | array('channel' => $pname['channel'], 'package' => $pname['package']), |
1817 | true) |
1817 | true) |
1818 | . $vs . |
1818 | . $vs . |
1819 | ', latest release is version ' . $info['version'] . |
1819 | ', latest release is version ' . $info['version'] . |
1820 | ', stability "' . $info['info']->getState() . '", use "' . |
1820 | ', stability "' . $info['info']->getState() . '", use "' . |
1821 | $this->_registry->parsedPackageNameToString( |
1821 | $this->_registry->parsedPackageNameToString( |
1822 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1822 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1823 | 'version' => $info['version'])) . '" to install', |
1823 | 'version' => $info['version'])) . '" to install', |
1824 | PEAR_DOWNLOADER_PACKAGE_STATE); |
1824 | PEAR_DOWNLOADER_PACKAGE_STATE); |
1825 | return $err; |
1825 | return $err; |
1826 | }
|
1826 | }
|
1827 | $err = PEAR::raiseError( |
1827 | $err = PEAR::raiseError( |
1828 | 'Failed to download ' . $this->_registry->parsedPackageNameToString( |
1828 | 'Failed to download ' . $this->_registry->parsedPackageNameToString( |
1829 | array('channel' => $pname['channel'], 'package' => $pname['package']), |
1829 | array('channel' => $pname['channel'], 'package' => $pname['package']), |
1830 | true) |
1830 | true) |
1831 | . $vs . |
1831 | . $vs . |
1832 | ', latest release is version ' . $info['version'] . |
1832 | ', latest release is version ' . $info['version'] . |
1833 | ', stability "' . $info['info']->getState() . '", use "' . |
1833 | ', stability "' . $info['info']->getState() . '", use "' . |
1834 | $this->_registry->parsedPackageNameToString( |
1834 | $this->_registry->parsedPackageNameToString( |
1835 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1835 | array('channel' => $pname['channel'], 'package' => $pname['package'], |
1836 | 'version' => $info['version'])) . '" to install'); |
1836 | 'version' => $info['version'])) . '" to install'); |
1837 | return $err; |
1837 | return $err; |
1838 | }
|
1838 | }
|
1839 | }
|
1839 | }
|
1840 | if (isset($info['deprecated']) && $info['deprecated']) { |
1840 | if (isset($info['deprecated']) && $info['deprecated']) { |
1841 | $this->_downloader->log(0, |
1841 | $this->_downloader->log(0, |
1842 | 'WARNING: "' . |
1842 | 'WARNING: "' . |
1843 | $this->_registry->parsedPackageNameToString( |
1843 | $this->_registry->parsedPackageNameToString( |
1844 | array('channel' => $info['info']->getChannel(), |
1844 | array('channel' => $info['info']->getChannel(), |
1845 | 'package' => $info['info']->getPackage()), true) . |
1845 | 'package' => $info['info']->getPackage()), true) . |
1846 | '" is deprecated in favor of "' . |
1846 | '" is deprecated in favor of "' . |
1847 | $this->_registry->parsedPackageNameToString($info['deprecated'], true) . |
1847 | $this->_registry->parsedPackageNameToString($info['deprecated'], true) . |
1848 | '"'); |
1848 | '"'); |
1849 | }
|
1849 | }
|
1850 | return $info; |
1850 | return $info; |
1851 | }
|
1851 | }
|
1852 | }
|
1852 | }
|
1853 | ?>
|
1853 | ?>
|
1854 | 1854 |