EMMA Coverage Report (generated Sun Sep 18 11:34:27 PHT 2011)
[all classes][org.apache.continuum.release.config]

COVERAGE SUMMARY FOR SOURCE FILE [ContinuumPropertiesReleaseDescriptorStore.java]

nameclass, %method, %block, %line, %
ContinuumPropertiesReleaseDescriptorStore.java100% (1/1)80%  (4/5)43%  (348/815)51%  (75.2/147)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class ContinuumPropertiesReleaseDescriptorStore100% (1/1)80%  (4/5)43%  (348/815)51%  (75.2/147)
processResolvedDependencies (Properties, Map): void 0%   (0/1)0%   (0/55)0%   (0/9)
loadResolvedDependencies (Properties, ReleaseDescriptor): void 100% (1/1)35%  (29/82)41%  (9/22)
write (ReleaseDescriptor, File): void 100% (1/1)44%  (162/369)51%  (32.2/63)
read (ReleaseDescriptor, File): ReleaseDescriptor 100% (1/1)50%  (154/306)63%  (33/52)
ContinuumPropertiesReleaseDescriptorStore (): void 100% (1/1)100% (3/3)100% (1/1)

1package org.apache.continuum.release.config;
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 
22import java.io.File;
23import java.io.FileInputStream;
24import java.io.FileNotFoundException;
25import java.io.FileOutputStream;
26import java.io.IOException;
27import java.io.InputStream;
28import java.io.OutputStream;
29import java.util.HashMap;
30import java.util.Iterator;
31import java.util.Map;
32import java.util.Map.Entry;
33import java.util.Properties;
34import java.util.Set;
35 
36import org.apache.maven.model.Scm;
37import org.apache.maven.shared.release.config.PropertiesReleaseDescriptorStore;
38import org.apache.maven.shared.release.config.ReleaseDescriptor;
39import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
40import org.apache.maven.shared.release.config.ReleaseUtils;
41import org.codehaus.plexus.util.IOUtil;
42 
43public class ContinuumPropertiesReleaseDescriptorStore
44    extends PropertiesReleaseDescriptorStore
45{
46    public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor, File file )
47        throws ReleaseDescriptorStoreException
48    {
49        Properties properties = new Properties();
50 
51        InputStream inStream = null;
52        try
53        {
54            inStream = new FileInputStream( file );
55 
56            properties.load( inStream );
57        }
58        catch ( FileNotFoundException e )
59        {
60            getLogger().debug( file.getName() + " not found - using empty properties" );
61        }
62        catch ( IOException e )
63        {
64            throw new ReleaseDescriptorStoreException(
65                "Error reading properties file '" + file.getName() + "': " + e.getMessage(), e );
66        }
67        finally
68        {
69            IOUtil.close( inStream );
70        }
71 
72        ContinuumReleaseDescriptor releaseDescriptor = new ContinuumReleaseDescriptor();
73        releaseDescriptor.setCompletedPhase( properties.getProperty( "completedPhase" ) );
74        releaseDescriptor.setScmSourceUrl( properties.getProperty( "scm.url" ) );
75        releaseDescriptor.setScmUsername( properties.getProperty( "scm.username" ) );
76        releaseDescriptor.setScmPassword( properties.getProperty( "scm.password" ) );
77        releaseDescriptor.setScmPrivateKey( properties.getProperty( "scm.privateKey" ) );
78        releaseDescriptor.setScmPrivateKeyPassPhrase( properties.getProperty( "scm.passphrase" ) );
79        releaseDescriptor.setScmTagBase( properties.getProperty( "scm.tagBase" ) );
80        releaseDescriptor.setScmReleaseLabel( properties.getProperty( "scm.tag" ) );
81        releaseDescriptor.setScmCommentPrefix( properties.getProperty( "scm.commentPrefix" ) );
82        releaseDescriptor.setAdditionalArguments( properties.getProperty( "exec.additionalArguments" ) );
83        releaseDescriptor.setPomFileName( properties.getProperty( "exec.pomFileName" ) );
84        releaseDescriptor.setPreparationGoals( properties.getProperty( "preparationGoals" ) );
85        releaseDescriptor.setExecutable( properties.getProperty( "build.executable" ) );
86 
87        loadResolvedDependencies( properties, releaseDescriptor );
88 
89        // boolean properties are not written to the properties file because the value from the caller is always used
90 
91        for ( Object o : properties.keySet() )
92        {
93            String property = (String) o;
94            if ( property.startsWith( "project.rel." ) )
95            {
96                releaseDescriptor.mapReleaseVersion( property.substring( "project.rel.".length() ),
97                                                     properties.getProperty( property ) );
98            }
99            else if ( property.startsWith( "project.dev." ) )
100            {
101                releaseDescriptor.mapDevelopmentVersion( property.substring( "project.dev.".length() ),
102                                                         properties.getProperty( property ) );
103            }
104            else if ( property.startsWith( "project.scm." ) )
105            {
106                int index = property.lastIndexOf( '.' );
107                if ( index > "project.scm.".length() )
108                {
109                    String key = property.substring( "project.scm.".length(), index );
110 
111                    if ( !releaseDescriptor.getOriginalScmInfo().containsKey( key ) )
112                    {
113                        if ( properties.getProperty( "project.scm." + key + ".empty" ) != null )
114                        {
115                            releaseDescriptor.mapOriginalScmInfo( key, null );
116                        }
117                        else
118                        {
119                            Scm scm = new Scm();
120                            scm.setConnection( properties.getProperty( "project.scm." + key + ".connection" ) );
121                            scm.setDeveloperConnection(
122                                properties.getProperty( "project.scm." + key + ".developerConnection" ) );
123                            scm.setUrl( properties.getProperty( "project.scm." + key + ".url" ) );
124                            scm.setTag( properties.getProperty( "project.scm." + key + ".tag" ) );
125 
126                            releaseDescriptor.mapOriginalScmInfo( key, scm );
127                        }
128                    }
129                }
130            }
131            else if ( property.startsWith( "build.env." ) )
132            {
133                releaseDescriptor.mapEnvironments( property.substring( "build.env.".length() ),
134                                                   properties.getProperty( property ) );
135            }
136        }
137 
138        if ( mergeDescriptor != null )
139        {
140            releaseDescriptor = (ContinuumReleaseDescriptor) ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
141            releaseDescriptor.setEnvironments( ( (ContinuumReleaseDescriptor) mergeDescriptor ).getEnvironments() );
142        }
143 
144        return releaseDescriptor;
145    }
146 
147    public void write( ReleaseDescriptor configFile, File file )
148        throws ReleaseDescriptorStoreException
149    {
150        ContinuumReleaseDescriptor config = (ContinuumReleaseDescriptor) configFile;
151        Properties properties = new Properties();
152        properties.setProperty( "completedPhase", config.getCompletedPhase() );
153        properties.setProperty( "scm.url", config.getScmSourceUrl() );
154        if ( config.getScmUsername() != null )
155        {
156            properties.setProperty( "scm.username", config.getScmUsername() );
157        }
158        if ( config.getScmPassword() != null )
159        {
160            properties.setProperty( "scm.password", config.getScmPassword() );
161        }
162        if ( config.getScmPrivateKey() != null )
163        {
164            properties.setProperty( "scm.privateKey", config.getScmPrivateKey() );
165        }
166        if ( config.getScmPrivateKeyPassPhrase() != null )
167        {
168            properties.setProperty( "scm.passphrase", config.getScmPrivateKeyPassPhrase() );
169        }
170        if ( config.getScmTagBase() != null )
171        {
172            properties.setProperty( "scm.tagBase", config.getScmTagBase() );
173        }
174        if ( config.getScmReleaseLabel() != null )
175        {
176            properties.setProperty( "scm.tag", config.getScmReleaseLabel() );
177        }
178        if ( config.getScmCommentPrefix() != null )
179        {
180            properties.setProperty( "scm.commentPrefix", config.getScmCommentPrefix() );
181        }
182        if ( config.getAdditionalArguments() != null )
183        {
184            properties.setProperty( "exec.additionalArguments", config.getAdditionalArguments() );
185        }
186        if ( config.getPomFileName() != null )
187        {
188            properties.setProperty( "exec.pomFileName", config.getPomFileName() );
189        }
190        if ( config.getPreparationGoals() != null )
191        {
192            properties.setProperty( "preparationGoals", config.getPreparationGoals() );
193        }
194 
195        // boolean properties are not written to the properties file because the value from the caller is always used
196 
197        for ( Object o : config.getReleaseVersions().entrySet() )
198        {
199            Entry entry = (Entry) o;
200            properties.setProperty( "project.rel." + entry.getKey(), (String) entry.getValue() );
201        }
202 
203        for ( Object o : config.getDevelopmentVersions().entrySet() )
204        {
205            Entry entry = (Entry) o;
206            properties.setProperty( "project.dev." + entry.getKey(), (String) entry.getValue() );
207        }
208 
209        for ( Object o : config.getOriginalScmInfo().entrySet() )
210        {
211            Entry entry = (Entry) o;
212            Scm scm = (Scm) entry.getValue();
213            String prefix = "project.scm." + entry.getKey();
214            if ( scm != null )
215            {
216                if ( scm.getConnection() != null )
217                {
218                    properties.setProperty( prefix + ".connection", scm.getConnection() );
219                }
220                if ( scm.getDeveloperConnection() != null )
221                {
222                    properties.setProperty( prefix + ".developerConnection", scm.getDeveloperConnection() );
223                }
224                if ( scm.getUrl() != null )
225                {
226                    properties.setProperty( prefix + ".url", scm.getUrl() );
227                }
228                if ( scm.getTag() != null )
229                {
230                    properties.setProperty( prefix + ".tag", scm.getTag() );
231                }
232            }
233            else
234            {
235                properties.setProperty( prefix + ".empty", "true" );
236            }
237        }
238 
239        for ( Object o : config.getEnvironments().entrySet() )
240        {
241            Entry entry = (Entry) o;
242            properties.setProperty( "build.env." + entry.getKey(), (String) entry.getValue() );
243        }
244 
245        if ( ( config.getResolvedSnapshotDependencies() != null ) &&
246            ( config.getResolvedSnapshotDependencies().size() > 0 ) )
247        {
248            processResolvedDependencies( properties, config.getResolvedSnapshotDependencies() );
249        }
250 
251        // executables
252        if ( config.getExecutable() != null )
253        {
254            properties.setProperty( "build.executable", config.getExecutable() );
255        }
256 
257        OutputStream outStream = null;
258        //noinspection OverlyBroadCatchBlock
259        try
260        {
261            outStream = new FileOutputStream( file );
262 
263            properties.store( outStream, "release configuration" );
264        }
265        catch ( IOException e )
266        {
267            throw new ReleaseDescriptorStoreException(
268                "Error writing properties file '" + file.getName() + "': " + e.getMessage(), e );
269        }
270        finally
271        {
272            IOUtil.close( outStream );
273        }
274 
275    }
276 
277    private void processResolvedDependencies( Properties prop, Map resolvedDependencies )
278    {
279        Set entries = resolvedDependencies.entrySet();
280        Iterator iterator = entries.iterator();
281        Entry currentEntry;
282 
283        while ( iterator.hasNext() )
284        {
285            currentEntry = (Entry) iterator.next();
286 
287            Map versionMap = (Map) currentEntry.getValue();
288 
289            prop.setProperty( "dependency." + currentEntry.getKey() + ".release",
290                              (String) versionMap.get( ReleaseDescriptor.RELEASE_KEY ) );
291            prop.setProperty( "dependency." + currentEntry.getKey() + ".development",
292                              (String) versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
293        }
294    }
295 
296    private void loadResolvedDependencies( Properties prop, ReleaseDescriptor descriptor )
297    {
298        Map<String, Map<String, Object>> resolvedDependencies = new HashMap<String, Map<String, Object>>();
299 
300        Set entries = prop.entrySet();
301        Iterator iterator = entries.iterator();
302        String propertyName;
303        Entry currentEntry;
304 
305        while ( iterator.hasNext() )
306        {
307            currentEntry = (Entry) iterator.next();
308            propertyName = (String) currentEntry.getKey();
309 
310            if ( propertyName.startsWith( "dependency." ) )
311            {
312                Map<String, Object> versionMap;
313                String artifactVersionlessKey;
314                int startIndex;
315                int endIndex;
316                String versionType;
317 
318                startIndex = propertyName.lastIndexOf( "dependency." );
319 
320                if ( propertyName.indexOf( ".development" ) != -1 )
321                {
322                    endIndex = propertyName.indexOf( ".development" );
323                    versionType = ReleaseDescriptor.DEVELOPMENT_KEY;
324                }
325                else
326                {
327                    endIndex = propertyName.indexOf( ".release" );
328                    versionType = ReleaseDescriptor.RELEASE_KEY;
329                }
330 
331                artifactVersionlessKey = propertyName.substring( startIndex, endIndex );
332 
333                if ( resolvedDependencies.containsKey( artifactVersionlessKey ) )
334                {
335                    versionMap = resolvedDependencies.get( artifactVersionlessKey );
336                }
337                else
338                {
339                    versionMap = new HashMap<String, Object>();
340                    resolvedDependencies.put( artifactVersionlessKey, versionMap );
341                }
342 
343                versionMap.put( versionType, currentEntry.getValue() );
344            }
345        }
346 
347        descriptor.setResolvedSnapshotDependencies( resolvedDependencies );
348    }
349}

[all classes][org.apache.continuum.release.config]
EMMA 2.0.5312 (C) Vladimir Roubtsov