Coverage Report

 package org.apache.maven.report.projectinfo;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.Authenticator;
 import java.net.PasswordAuthentication;
 import java.net.URL;
 import java.net.URLConnection;
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.cert.X509Certificate;
 import java.util.Collections;
 import java.util.List;
 import java.util.Properties;
 
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.HttpsURLConnection;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 
 import org.apache.commons.lang.math.NumberUtils;
 import org.apache.commons.validator.UrlValidator;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.artifact.factory.ArtifactFactory;
 import org.apache.maven.artifact.repository.ArtifactRepository;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.project.MavenProjectBuilder;
 import org.apache.maven.project.ProjectBuildingException;
 import org.apache.maven.reporting.AbstractMavenReportRenderer;
 import org.apache.maven.settings.Proxy;
 import org.apache.maven.settings.Server;
 import org.apache.maven.settings.Settings;
 import org.codehaus.plexus.util.Base64;
 import org.codehaus.plexus.util.IOUtil;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
  * Utilities methods.
  *
  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
  * @version $Id: ProjectInfoReportUtils.java 1098769 2011-05-02 20:00:24Z hboutemy $
  * @since 2.1
  */
 public class ProjectInfoReportUtils
 {
     private static final UrlValidator URL_VALIDATOR = new UrlValidator( new String[] { "http", "https" } );
 
     /** The timeout when getting the url input stream */
     private static final int TIMEOUT = 1000 * 5;
 
     /**
      * Get the input stream using ISO-8859-1 as charset from an URL.
      *
      * @param url not null
      * @param settings not null to handle proxy settings
      * @return the ISO-8859-1 inputstream found.
      * @throws IOException if any
      * @see #getContent(URL, Settings, String)
      */
     public static String getContent( URL url, Settings settings )
         throws IOException
     {
         return getContent( url, settings, "ISO-8859-1" );
     }
 
     /**
      * Get the input stream from an URL.
      *
      * @param url not null
      * @param settings not null to handle proxy settings
      * @param encoding the wanted encoding for the inputstream. If null, encoding will be "ISO-8859-1".
      * @return the inputstream found depending the wanted encoding.
      * @throws IOException if any
      */
     public static String getContent( URL url, Settings settings, String encoding )
         throws IOException
     {
         return getContent( url, null, settings, encoding );
     }
 
     /**
      * Get the input stream from an URL.
      *
      * @param url not null
      * @param project could be null
      * @param settings not null to handle proxy settings
      * @param encoding the wanted encoding for the inputstream. If empty, encoding will be "ISO-8859-1".
      * @return the inputstream found depending the wanted encoding.
      * @throws IOException if any
      * @since 2.3
      */
     public static String getContent( URL url, MavenProject project, Settings settings, String encoding )
         throws IOException
     {
         String scheme = url.getProtocol();
 
         if ( StringUtils.isEmpty( encoding ) )
         {
             encoding = "ISO-8859-1";
         }
 
         if ( "file".equals( scheme ) )
         {
             InputStream in = null;
             try
             {
                 URLConnection conn = url.openConnection();
                 in = conn.getInputStream();
 
                 return IOUtil.toString( in, encoding );
             }
             finally
             {
                 IOUtil.close( in );
             }
         }
 
         Proxy proxy = settings.getActiveProxy();
         if ( proxy != null )
         {
             if ( "http".equals( scheme ) || "https".equals( scheme ) || "ftp".equals( scheme ) )
             {
                 scheme += ".";
             }
             else
             {
                 scheme = "";
             }
 
             String host = proxy.getHost();
             if ( !StringUtils.isEmpty( host ) )
             {
                 Properties p = System.getProperties();
                 p.setProperty( scheme + "proxySet", "true" );
                 p.setProperty( scheme + "proxyHost", host );
                 p.setProperty( scheme + "proxyPort", String.valueOf( proxy.getPort() ) );
                 if ( !StringUtils.isEmpty( proxy.getNonProxyHosts() ) )
                 {
                     p.setProperty( scheme + "nonProxyHosts", proxy.getNonProxyHosts() );
                 }
 
                 final String userName = proxy.getUsername();
                 if ( !StringUtils.isEmpty( userName ) )
                 {
                     final String pwd = StringUtils.isEmpty( proxy.getPassword() ) ? "" : proxy.getPassword();
                     Authenticator.setDefault( new Authenticator()
                     {
                         /** {@inheritDoc} */
                         protected PasswordAuthentication getPasswordAuthentication()
                         {
                             return new PasswordAuthentication( userName, pwd.toCharArray() );
                         }
                     } );
                 }
             }
         }
 
         InputStream in = null;
         try
         {
             URLConnection conn = getURLConnection( url, project, settings );
             in = conn.getInputStream();
 
             return IOUtil.toString( in, encoding );
         }
         finally
         {
             IOUtil.close( in );
         }
     }
 
     /**
      * @param factory not null
      * @param artifact not null
      * @param mavenProjectBuilder not null
      * @param remoteRepositories not null
      * @param localRepository not null
      * @return the artifact url or null if an error occurred.
      */
     public static String getArtifactUrl( ArtifactFactory factory, Artifact artifact,
                                          MavenProjectBuilder mavenProjectBuilder,
                                          List<ArtifactRepository> remoteRepositories, ArtifactRepository localRepository )
     {
         if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
         {
             return null;
         }
 
         Artifact copyArtifact = ArtifactUtils.copyArtifact( artifact );
         if ( !"pom".equals( copyArtifact.getType() ) )
         {
             copyArtifact =
                 factory.createProjectArtifact( copyArtifact.getGroupId(), copyArtifact.getArtifactId(),
                                                copyArtifact.getVersion(), copyArtifact.getScope() );
         }
         try
         {
             MavenProject pluginProject =
                 mavenProjectBuilder.buildFromRepository( copyArtifact,
                                                          remoteRepositories == null ? Collections.EMPTY_LIST
                                                                          : remoteRepositories, localRepository );
 
             if ( isArtifactUrlValid( pluginProject.getUrl() ) )
             {
                 return pluginProject.getUrl();
             }
 
             return null;
         }
         catch ( ProjectBuildingException e )
         {
             return null;
         }
     }
 
     /**
      * @param artifactId not null
      * @param link could be null
      * @return the artifactId cell with or without a link pattern
      * @see AbstractMavenReportRenderer#linkPatternedText(String)
      */
     public static String getArtifactIdCell( String artifactId, String link )
     {
         if ( StringUtils.isEmpty( link ) )
         {
             return artifactId;
         }
 
         return "{" + artifactId + "," + link + "}";
     }
 
     /**
      * @param url not null
      * @return <code>true</code> if the url is valid, <code>false</code> otherwise.
      */
     public static boolean isArtifactUrlValid( String url )
     {
         if ( StringUtils.isEmpty( url ) )
         {
             return false;
         }
 
         return URL_VALIDATOR.isValid( url );
     }
 
     /**
      * @param url not null
      * @param project not null
      * @param settings not null
      * @return the url connection with auth if required. Don't check the certificate if SSL scheme.
      * @throws IOException if any
      */
     private static URLConnection getURLConnection( URL url, MavenProject project, Settings settings )
         throws IOException
     {
         URLConnection conn = url.openConnection();
         conn.setConnectTimeout( TIMEOUT );
         conn.setReadTimeout( TIMEOUT );
 
         // conn authorization
         if ( settings.getServers() != null
             && !settings.getServers().isEmpty()
             && project != null
             && project.getDistributionManagement() != null
             && ( project.getDistributionManagement().getRepository() != null || project.getDistributionManagement().getSnapshotRepository() != null )
             && ( StringUtils.isNotEmpty( project.getDistributionManagement().getRepository().getUrl() ) || StringUtils.isNotEmpty( project.getDistributionManagement().getSnapshotRepository().getUrl() ) ) )
         {
             Server server = null;
             if ( url.toString().contains( project.getDistributionManagement().getRepository().getUrl() ) )
             {
                 server = settings.getServer( project.getDistributionManagement().getRepository().getId() );
             }
             if ( server == null
                 && url.toString().contains( project.getDistributionManagement().getSnapshotRepository().getUrl() ) )
             {
                 server = settings.getServer( project.getDistributionManagement().getSnapshotRepository().getId() );
             }
 
             if ( server != null && StringUtils.isNotEmpty( server.getUsername() )
                 && StringUtils.isNotEmpty( server.getPassword() ) )
             {
                 String up = server.getUsername().trim() + ":" + server.getPassword().trim();
                 String upEncoded = new String( Base64.encodeBase64Chunked( up.getBytes() ) ).trim();
 
                 conn.setRequestProperty( "Authorization", "Basic " + upEncoded );
             }
         }
 
         if ( conn instanceof HttpsURLConnection )
         {
             HostnameVerifier hostnameverifier = new HostnameVerifier()
             {
                 /** {@inheritDoc} */
                 public boolean verify( String urlHostName, SSLSession session )
                 {
                     return true;
                 }
             };
             ( (HttpsURLConnection) conn ).setHostnameVerifier( hostnameverifier );
 
             TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager()
             {
                 /** {@inheritDoc} */
                 public void checkClientTrusted( final X509Certificate[] chain, final String authType )
                 {
                 }
 
                 /** {@inheritDoc} */
                 public void checkServerTrusted( final X509Certificate[] chain, final String authType )
                 {
                 }
 
                 /** {@inheritDoc} */
                 public X509Certificate[] getAcceptedIssuers()
                 {
                     return null;
                 }
             } };
 
             try
             {
                 SSLContext sslContext = SSLContext.getInstance( "SSL" );
                 sslContext.init( null, trustAllCerts, new SecureRandom() );
 
                 SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
 
                 ( (HttpsURLConnection) conn ).setSSLSocketFactory( sslSocketFactory );
             }
             catch ( NoSuchAlgorithmException e1 )
             {
                 // ignore
             }
             catch ( KeyManagementException e )
             {
                 // ignore
             }
         }
 
         return conn;
     }
 
     public static boolean isNumber( String str )
     {
         if ( str.startsWith( "+" ) )
         {
             str = str.substring( 1 );
         }
         return NumberUtils.isNumber( str );
     }
 
     public static float toFloat( String str, float defaultValue )
     {
         if ( str.startsWith( "+" ) )
         {
             str = str.substring( 1 );
         }
         return NumberUtils.toFloat( str, defaultValue );
     }
 }

1		package org.apache.maven.report.projectinfo;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.IOException;
23		import java.io.InputStream;
24		import java.net.Authenticator;
25		import java.net.PasswordAuthentication;
26		import java.net.URL;
27		import java.net.URLConnection;
28		import java.security.KeyManagementException;
29		import java.security.NoSuchAlgorithmException;
30		import java.security.SecureRandom;
31		import java.security.cert.X509Certificate;
32		import java.util.Collections;
33		import java.util.List;
34		import java.util.Properties;
35
36		import javax.net.ssl.HostnameVerifier;
37		import javax.net.ssl.HttpsURLConnection;
38		import javax.net.ssl.SSLContext;
39		import javax.net.ssl.SSLSession;
40		import javax.net.ssl.SSLSocketFactory;
41		import javax.net.ssl.TrustManager;
42		import javax.net.ssl.X509TrustManager;
43
44		import org.apache.commons.lang.math.NumberUtils;
45		import org.apache.commons.validator.UrlValidator;
46		import org.apache.maven.artifact.Artifact;
47		import org.apache.maven.artifact.ArtifactUtils;
48		import org.apache.maven.artifact.factory.ArtifactFactory;
49		import org.apache.maven.artifact.repository.ArtifactRepository;
50		import org.apache.maven.project.MavenProject;
51		import org.apache.maven.project.MavenProjectBuilder;
52		import org.apache.maven.project.ProjectBuildingException;
53		import org.apache.maven.reporting.AbstractMavenReportRenderer;
54		import org.apache.maven.settings.Proxy;
55		import org.apache.maven.settings.Server;
56		import org.apache.maven.settings.Settings;
57		import org.codehaus.plexus.util.Base64;
58		import org.codehaus.plexus.util.IOUtil;
59		import org.codehaus.plexus.util.StringUtils;
60
61		/**
62		* Utilities methods.
63		*
64		* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
65		* @version $Id: ProjectInfoReportUtils.java 1098769 2011-05-02 20:00:24Z hboutemy $
66		* @since 2.1
67		*/
68	0	public class ProjectInfoReportUtils
69		{
70	1	private static final UrlValidator URL_VALIDATOR = new UrlValidator( new String[] { "http", "https" } );
71
72		/** The timeout when getting the url input stream */
73		private static final int TIMEOUT = 1000 * 5;
74
75		/**
76		* Get the input stream using ISO-8859-1 as charset from an URL.
77		*
78		* @param url not null
79		* @param settings not null to handle proxy settings
80		* @return the ISO-8859-1 inputstream found.
81		* @throws IOException if any
82		* @see #getContent(URL, Settings, String)
83		*/
84		public static String getContent( URL url, Settings settings )
85		throws IOException
86		{
87	1	return getContent( url, settings, "ISO-8859-1" );
88		}
89
90		/**
91		* Get the input stream from an URL.
92		*
93		* @param url not null
94		* @param settings not null to handle proxy settings
95		* @param encoding the wanted encoding for the inputstream. If null, encoding will be "ISO-8859-1".
96		* @return the inputstream found depending the wanted encoding.
97		* @throws IOException if any
98		*/
99		public static String getContent( URL url, Settings settings, String encoding )
100		throws IOException
101		{
102	1	return getContent( url, null, settings, encoding );
103		}
104
105		/**
106		* Get the input stream from an URL.
107		*
108		* @param url not null
109		* @param project could be null
110		* @param settings not null to handle proxy settings
111		* @param encoding the wanted encoding for the inputstream. If empty, encoding will be "ISO-8859-1".
112		* @return the inputstream found depending the wanted encoding.
113		* @throws IOException if any
114		* @since 2.3
115		*/
116		public static String getContent( URL url, MavenProject project, Settings settings, String encoding )
117		throws IOException
118		{
119	6	String scheme = url.getProtocol();
120
121	6	if ( StringUtils.isEmpty( encoding ) )
122		{
123	5	encoding = "ISO-8859-1";
124		}
125
126	6	if ( "file".equals( scheme ) )
127		{
128	1	InputStream in = null;
129		try
130		{
131	1	URLConnection conn = url.openConnection();
132	1	in = conn.getInputStream();
133
134	1	return IOUtil.toString( in, encoding );
135		}
136		finally
137		{
138	1	IOUtil.close( in );
139		}
140		}
141
142	5	Proxy proxy = settings.getActiveProxy();
143	5	if ( proxy != null )
144		{
145	0	if ( "http".equals( scheme ) \|\| "https".equals( scheme ) \|\| "ftp".equals( scheme ) )
146		{
147	0	scheme += ".";
148		}
149		else
150		{
151	0	scheme = "";
152		}
153
154	0	String host = proxy.getHost();
155	0	if ( !StringUtils.isEmpty( host ) )
156		{
157	0	Properties p = System.getProperties();
158	0	p.setProperty( scheme + "proxySet", "true" );
159	0	p.setProperty( scheme + "proxyHost", host );
160	0	p.setProperty( scheme + "proxyPort", String.valueOf( proxy.getPort() ) );
161	0	if ( !StringUtils.isEmpty( proxy.getNonProxyHosts() ) )
162		{
163	0	p.setProperty( scheme + "nonProxyHosts", proxy.getNonProxyHosts() );
164		}
165
166	0	final String userName = proxy.getUsername();
167	0	if ( !StringUtils.isEmpty( userName ) )
168		{
169	0	final String pwd = StringUtils.isEmpty( proxy.getPassword() ) ? "" : proxy.getPassword();
170	0	Authenticator.setDefault( new Authenticator()
171	0	{
172		/** {@inheritDoc} */
173		protected PasswordAuthentication getPasswordAuthentication()
174		{
175	0	return new PasswordAuthentication( userName, pwd.toCharArray() );
176		}
177		} );
178		}
179		}
180		}
181
182	5	InputStream in = null;
183		try
184		{
185	5	URLConnection conn = getURLConnection( url, project, settings );
186	5	in = conn.getInputStream();
187
188	5	return IOUtil.toString( in, encoding );
189		}
190		finally
191		{
192	5	IOUtil.close( in );
193		}
194		}
195
196		/**
197		* @param factory not null
198		* @param artifact not null
199		* @param mavenProjectBuilder not null
200		* @param remoteRepositories not null
201		* @param localRepository not null
202		* @return the artifact url or null if an error occurred.
203		*/
204		public static String getArtifactUrl( ArtifactFactory factory, Artifact artifact,
205		MavenProjectBuilder mavenProjectBuilder,
206		List<ArtifactRepository> remoteRepositories, ArtifactRepository localRepository )
207		{
208	2	if ( Artifact.SCOPE_SYSTEM.equals( artifact.getScope() ) )
209		{
210	0	return null;
211		}
212
213	2	Artifact copyArtifact = ArtifactUtils.copyArtifact( artifact );
214	2	if ( !"pom".equals( copyArtifact.getType() ) )
215		{
216	1	copyArtifact =
217		factory.createProjectArtifact( copyArtifact.getGroupId(), copyArtifact.getArtifactId(),
218		copyArtifact.getVersion(), copyArtifact.getScope() );
219		}
220		try
221		{
222	2	MavenProject pluginProject =
223		mavenProjectBuilder.buildFromRepository( copyArtifact,
224		remoteRepositories == null ? Collections.EMPTY_LIST
225		: remoteRepositories, localRepository );
226
227	2	if ( isArtifactUrlValid( pluginProject.getUrl() ) )
228		{
229	2	return pluginProject.getUrl();
230		}
231
232	0	return null;
233		}
234	0	catch ( ProjectBuildingException e )
235		{
236	0	return null;
237		}
238		}
239
240		/**
241		* @param artifactId not null
242		* @param link could be null
243		* @return the artifactId cell with or without a link pattern
244		* @see AbstractMavenReportRenderer#linkPatternedText(String)
245		*/
246		public static String getArtifactIdCell( String artifactId, String link )
247		{
248	6	if ( StringUtils.isEmpty( link ) )
249		{
250	2	return artifactId;
251		}
252
253	4	return "{" + artifactId + "," + link + "}";
254		}
255
256		/**
257		* @param url not null
258		* @return <code>true</code> if the url is valid, <code>false</code> otherwise.
259		*/
260		public static boolean isArtifactUrlValid( String url )
261		{
262	3	if ( StringUtils.isEmpty( url ) )
263		{
264	0	return false;
265		}
266
267	3	return URL_VALIDATOR.isValid( url );
268		}
269
270		/**
271		* @param url not null
272		* @param project not null
273		* @param settings not null
274		* @return the url connection with auth if required. Don't check the certificate if SSL scheme.
275		* @throws IOException if any
276		*/
277		private static URLConnection getURLConnection( URL url, MavenProject project, Settings settings )
278		throws IOException
279		{
280	5	URLConnection conn = url.openConnection();
281	5	conn.setConnectTimeout( TIMEOUT );
282	5	conn.setReadTimeout( TIMEOUT );
283
284		// conn authorization
285	5	if ( settings.getServers() != null
286		&& !settings.getServers().isEmpty()
287		&& project != null
288		&& project.getDistributionManagement() != null
289		&& ( project.getDistributionManagement().getRepository() != null \|\| project.getDistributionManagement().getSnapshotRepository() != null )
290		&& ( StringUtils.isNotEmpty( project.getDistributionManagement().getRepository().getUrl() ) \|\| StringUtils.isNotEmpty( project.getDistributionManagement().getSnapshotRepository().getUrl() ) ) )
291		{
292	4	Server server = null;
293	4	if ( url.toString().contains( project.getDistributionManagement().getRepository().getUrl() ) )
294		{
295	3	server = settings.getServer( project.getDistributionManagement().getRepository().getId() );
296		}
297	4	if ( server == null
298		&& url.toString().contains( project.getDistributionManagement().getSnapshotRepository().getUrl() ) )
299		{
300	0	server = settings.getServer( project.getDistributionManagement().getSnapshotRepository().getId() );
301		}
302
303	4	if ( server != null && StringUtils.isNotEmpty( server.getUsername() )
304		&& StringUtils.isNotEmpty( server.getPassword() ) )
305		{
306	3	String up = server.getUsername().trim() + ":" + server.getPassword().trim();
307	3	String upEncoded = new String( Base64.encodeBase64Chunked( up.getBytes() ) ).trim();
308
309	3	conn.setRequestProperty( "Authorization", "Basic " + upEncoded );
310		}
311		}
312
313	5	if ( conn instanceof HttpsURLConnection )
314		{
315	2	HostnameVerifier hostnameverifier = new HostnameVerifier()
316	2	{
317		/** {@inheritDoc} */
318		public boolean verify( String urlHostName, SSLSession session )
319		{
320	2	return true;
321		}
322		};
323	2	( (HttpsURLConnection) conn ).setHostnameVerifier( hostnameverifier );
324
325	2	TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager()
326	2	{
327		/** {@inheritDoc} */
328		public void checkClientTrusted( final X509Certificate[] chain, final String authType )
329		{
330	0	}
331
332		/** {@inheritDoc} */
333		public void checkServerTrusted( final X509Certificate[] chain, final String authType )
334		{
335	2	}
336
337		/** {@inheritDoc} */
338		public X509Certificate[] getAcceptedIssuers()
339		{
340	0	return null;
341		}
342		} };
343
344		try
345		{
346	2	SSLContext sslContext = SSLContext.getInstance( "SSL" );
347	2	sslContext.init( null, trustAllCerts, new SecureRandom() );
348
349	2	SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
350
351	2	( (HttpsURLConnection) conn ).setSSLSocketFactory( sslSocketFactory );
352		}
353	0	catch ( NoSuchAlgorithmException e1 )
354		{
355		// ignore
356		}
357	0	catch ( KeyManagementException e )
358		{
359		// ignore
360	2	}
361		}
362
363	5	return conn;
364		}
365
366		public static boolean isNumber( String str )
367		{
368	2	if ( str.startsWith( "+" ) )
369		{
370	0	str = str.substring( 1 );
371		}
372	2	return NumberUtils.isNumber( str );
373		}
374
375		public static float toFloat( String str, float defaultValue )
376		{
377	2	if ( str.startsWith( "+" ) )
378		{
379	0	str = str.substring( 1 );
380		}
381	2	return NumberUtils.toFloat( str, defaultValue );
382		}
383		}