Coverage Report

Coverage Report - org.apache.commons.jjar.JJAR

Classes in this File

Line Coverage

Branch Coverage

Complexity

JJAR

0/216

0/94

8.625

 /*
  * Copyright 2001,2004 The Apache Software Foundation.
  * 
  * Licensed 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.
  */
 
 package org.apache.commons.jjar;
 
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Iterator;
 import java.net.URLConnection;
 import java.net.URL;
 
 /**
  *  JJAR command line program
  *
  *  @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
  *  @version $Id: JJAR.java 155454 2005-02-26 13:23:34Z dirkv $
  */
 public class JJAR
 {
     public static String title = "JJAR : Jakarta Jar Archive Respository v@version@";
     public static String defaultRepository = ClasspathUtil.getDefaultRepository();
 
     public static void main( String args[])
     {
         /*
          *  first thing is the verb
          */
 
         if (args.length < 1 )
         {
             System.out.println(title);
             return;
         }
 
         String verb = args[0];
         Class [] ca = {args.getClass() };
         Object [] arg = { args };
 
         try 
         {
             Method m = Class.forName("org.apache.commons.jjar.JJAR").getMethod(verb, ca );
 
             m.invoke( null, arg );
         }
         catch( NoSuchMethodException nsme )
         {
             System.out.println("JJAR : invalid action " + verb );
             JJAR.help(  args );
         }
         catch( Exception e )
         {
             System.out.println("JJAR : exception : " + e );
         }
     }
 
     public static void help( String args[] )
     {
         header();
         
         System.out.println("list : list the JJAR packages in the repository");
         System.out.println("fetch : fetch a JJAR package from the repository");
         System.out.println("See the README.txt for more info.");
     }
 
     public static void fetch( String args[] )
     {
         boolean classpath = false;
         String jarname = null;
         String packagename = null;
         String version = null;
         boolean verifyignore = false;
         boolean getdeps = true;
         boolean onlydeps = false;
 
         String dir = ".";
 
         if ( args.length < 3 )
         {
             System.out.println("Usage :  fetch [-v] [-od] -j jarname -p package -v version ");
             return;
         }
 
         for( int i = 1; i < args.length; i++)
         {
             String arg = args[i];
 
             if (arg.startsWith("-"))
             {
                 if (arg.equals("-j"))
                 {
                     jarname = args[i+1];
                     i++;
                 }
                 else if (arg.equals("-p"))
                 {
                     packagename = args[i+1];
                     i++;
                 }
                 else if (arg.equals("-v"))
                 {
                     version = args[i+1];
                     i++;
                 }
                 else if (arg.equals("-c"))
                 {
                     classpath = true;
                 }
                 else if (arg.equals("-vi"))
                 {
                     verifyignore = true;
                 }
                 else if( arg.equals("-d"))
                 {
                     dir = args[i+1];
                     i++;
                 }
                 else if( arg.equals("-nd"))
                 {
                     getdeps = false;
                 }
                 else if( arg.equals("-od"))
                 {
                     onlydeps = true;
                 }
                 
             }
         }
 
         if ( packagename == null)
         {
             System.out.println("Usage :  fetch -j jarname -p package -v version ");
             return;
         }
 
         /*
          * now go get
          */
         
         try
         {
             /*
              *  get the repository info
              */
 
             Repository rep = new RepositoryXML();
             rep.load( new URL( defaultRepository + "repository.xml") );
         
             /*
              *  get the fetch target
              */
 
             if( version == null)
                 version = rep.getPackageDefaultVersion( packagename );
 
             System.out.println("Fetching " + packagename + " v" + version + " into file " + (jarname == null? "<default name>" : jarname ) );
  
             String fetchTarget = rep.getFetchTarget( packagename, version );
 
             if (fetchTarget == null)
             {
                 System.out.println("JJAR.fetch : target not found for " + packagename + " v" + version );
                 return;
             }
 
             /*
              *  are there any dependencies for this fetch target?
              */
 
             String deptarget = "";
 
             if (getdeps)
             {
                 List deplist = rep.getDependencyList( packagename, version );
                 
                 Iterator ii = deplist.iterator();
                 
                 while(ii.hasNext())
                 {
                     /*
                      *  for now, use the fetchtarget names
                      */
                     
                     String depnameuni = (String) ii.next();
                     
                     JJARPackage jjarp = new JJARPackage( depnameuni );
                     
                     String depname = jjarp.getName();
                     String depver = jjarp.getVersionString();
                     
                     deptarget = rep.getFetchTarget( depname, depver );
                     
                     if( deptarget == null)
                     {
                         System.out.println("  Repository error : returned null for dependency " + depname + " v" + depver 
                                            + " Skipping.");
                         continue;
                     }
                     
                     /*
                      *  check to see if exists if verifyignore
                      */
 
   
                     if (verifyignore )
                     {
                         JJARPackage jpak = null;
                         
                         try
                         {
                             jpak = ClasspathUtil.getPackage( dir + "/" + deptarget );
                         }
                         catch(Exception e)
                         {
                             // ignore 
                         }
 
                         if (jpak != null)
                         {
                             if( jpak.equals( depname, depver ))
                             {
                                 System.out.println(" Dependency '" + depname + "' exists.  Skipping.");
                                 continue;
                             }
                         }
                     }
                      
                     /*
                      *  now get it
                      */
 
                     URL url = new URL( defaultRepository + deptarget );
                     URLConnection uconn  = (URLConnection) url.openConnection(); 
                     
                     System.out.println(" Fetching dependency : " + deptarget + " to " + dir + "/" + deptarget  );
 
                     Transport.fetchJar( uconn, dir + "/" + deptarget );                
                 }
             }
 
             /*
              *  now the actual jar.  If we are told to ignore the deps, so be it
              */
 
             if ( onlydeps )
             {
                 return;
             }
 
             /*
              *  if verifyignore then check the jar to see if it satisfies the request
              */
             
             if (jarname == null)
                 jarname = fetchTarget;
 
             if( verifyignore)
             {
                 try
                 {
                     JJARPackage packageinfo = ClasspathUtil.getPackage( dir + "/" + jarname );
 
                     if( packageinfo.equals( packagename, version ))
                     {
                         System.out.println("Target exists.  skipping fetch");
                         return;
                     }
                 }
                 catch(Exception e)
                 {
                     // ignore and continue
                 }
             }
 
             URL url = new URL( defaultRepository + fetchTarget );
             URLConnection uconn  = (URLConnection) url.openConnection(); 
 
             String destjar = dir + "/" + jarname;
 
             System.out.println(" Fetching target : " + fetchTarget + " to " + destjar );
 
             Transport.fetchJar( uconn, destjar);
         }
         catch( Exception e )
         {
             System.out.println("JJAR.fetch : exception " + e );
             e.printStackTrace();
         } 
      }
 
     public static void verify( String args[] )
     {
         header();
 
         /*
          *  do we do it to classpath, or was a jar specified
          */
 
         String flag = null;
         String jarname = null;
 
         if (args.length > 1 )
         {
             flag = args[1];
 
             if (flag.equals("-j"))
             {
                 if (args.length >= 3)
                 {
                     jarname = args[2];
     
                     try 
                     {
                         JJARPackage jjarp = ClasspathUtil.getPackage( jarname );
                         
                         if (jjarp != null)
                             System.out.println("    " + jjarp.getName() + " v" + jjarp.getVersionString() );
                         else
                             System.out.println("    " + jarname + "not a jjar compatable jar");
                     }
                     catch( Exception e )
                     {
                     }
                 }
             }
             else
             {
                 /*
                  * do the classpath
                  */
                 List jars = ClasspathUtil.getJarList( null );
                 
                 Iterator i = jars.iterator();
                 
                 while( i.hasNext() )
                 {
                     String jar =  (String) i.next();
                     
                     try 
                     {
                         JJARPackage jjarp = ClasspathUtil.getPackage( jar );
                         
                         if (jjarp != null)
                             System.out.println("    " + jjarp.getName() + " v" + jjarp.getVersionString() );
                         else
                             System.out.println("    " + jar + "not a jjar compatable jar");
                     }
                     catch( Exception e )
                     {
                     }
                 }
             }
         }
         else
         {
             System.out.println(" usage : verify -c | -j jarname");
         }
         return;
     }
 
     public static void list( String args[] ) 
     {
         header();
 
         try
         {
             URL url = new URL(defaultRepository + "repository.xml");
             
             Repository rep = new RepositoryXML();
             rep.load(url);
 
             if (args.length >= 3 )
             {
                 String flag = args[1];
 
                 if (flag.equals("-p"))
                 {
                     String pkg = args[2];
                 
                     dumpInfo( rep, pkg );
                 }
             }
             else
             {
                 System.out.println("Repository contains " + rep.getPackageCount() + " packages : " );
 
                 Iterator i = rep.getPackageListIter();
            
                 while( i.hasNext() )
                 {
                     String p = (String) i.next();
                     dumpInfo( rep, p );
                     System.out.println("");
                 }
             }
         }
         catch( Exception e )
         {
             System.out.println("JJAR.list : exception " + e );
             e.printStackTrace();
         } 
     }
 
     private static void dumpInfo(Repository rep, String p )
     {
         System.out.println(" " + p );
         System.out.println("    desc     : " + rep.getPackageDescription( p ) );
         System.out.println("    default  : " + rep.getPackageDefaultVersion( p ));
         System.out.println("    versions : ");
         
         List l = rep.getPackageVersionList( p );
         
         Iterator ii = l.iterator();
         
         while( ii.hasNext() )
         {
             String version = (String) ii.next() ;
 
             System.out.print(  "      " + version + " deps : "  );
             
             List depl = rep.getDependencyList( p, version );
             
             Iterator iii = depl.iterator();
             
             while( iii.hasNext() )
             {
                 System.out.print( iii.next() + ", " );
             }   
             
             System.out.println("");
         }
              
        System.out.println("--");
       
     }
 
     public static void mark( String args[] )
     {
         //   mark -j jarname -p package -v version
 
         String packagename = null;
         String jarname = null;
         String version = null;
 
         if ( args.length < 7 )
         {
             System.out.println("Usage : mark  -j jarname -p package -v version ");
             return;
         }
 
         for( int i = 1; i < args.length; i++)
         {
             String arg = args[i];
 
             if (arg.startsWith("-"))
             {
                 if (arg.equals("-j"))
                 {
                     jarname = args[i+1];
                     i++;
                 }
                 else if (arg.equals("-p"))
                 {
                     packagename = args[i+1];
                     i++;
                 }
                 else if (arg.equals("-v"))
                 {
                     version = args[i+1];
                     i++;
                 }
                 
             }
         }
 
         if ( packagename == null || jarname == null || version == null)
         {
             System.out.println("Usage :  mark -j jarname -p package -v version ");
             return;
         }
         
         try
         {
             if (ClasspathUtil.markJar( jarname, packagename, version ))
                 System.out.println("successful");
 
         }
         catch( Exception e)
         {
             System.out.println("Exception e : " + e );
             }
         
     }
 
     private static void header()
     {
         System.out.println(title);
         System.out.println(" - using repository " + defaultRepository);
        System.out.println("---------------------------------------------");
         System.out.println("");
     }
 }

1		/*
2		* Copyright 2001,2004 The Apache Software Foundation.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package org.apache.commons.jjar;
18
19		import java.lang.reflect.Method;
20		import java.util.List;
21		import java.util.Iterator;
22		import java.net.URLConnection;
23		import java.net.URL;
24
25		/**
26		* JJAR command line program
27		*
28		* @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
29		* @version $Id: JJAR.java 155454 2005-02-26 13:23:34Z dirkv $
30		*/
31	0	public class JJAR
32		{
33	0	public static String title = "JJAR : Jakarta Jar Archive Respository v@version@";
34	0	public static String defaultRepository = ClasspathUtil.getDefaultRepository();
35
36		public static void main( String args[])
37		{
38		/*
39		* first thing is the verb
40		*/
41
42	0	if (args.length < 1 )
43		{
44	0	System.out.println(title);
45	0	return;
46		}
47
48	0	String verb = args[0];
49	0	Class [] ca = {args.getClass() };
50	0	Object [] arg = { args };
51
52		try
53		{
54	0	Method m = Class.forName("org.apache.commons.jjar.JJAR").getMethod(verb, ca );
55
56	0	m.invoke( null, arg );
57		}
58	0	catch( NoSuchMethodException nsme )
59		{
60	0	System.out.println("JJAR : invalid action " + verb );
61	0	JJAR.help( args );
62		}
63	0	catch( Exception e )
64		{
65	0	System.out.println("JJAR : exception : " + e );
66	0	}
67	0	}
68
69		public static void help( String args[] )
70		{
71	0	header();
72
73	0	System.out.println("list : list the JJAR packages in the repository");
74	0	System.out.println("fetch : fetch a JJAR package from the repository");
75	0	System.out.println("See the README.txt for more info.");
76	0	}
77
78		public static void fetch( String args[] )
79		{
80	0	boolean classpath = false;
81	0	String jarname = null;
82	0	String packagename = null;
83	0	String version = null;
84	0	boolean verifyignore = false;
85	0	boolean getdeps = true;
86	0	boolean onlydeps = false;
87
88	0	String dir = ".";
89
90	0	if ( args.length < 3 )
91		{
92	0	System.out.println("Usage : fetch [-v] [-od] -j jarname -p package -v version ");
93	0	return;
94		}
95
96	0	for( int i = 1; i < args.length; i++)
97		{
98	0	String arg = args[i];
99
100	0	if (arg.startsWith("-"))
101		{
102	0	if (arg.equals("-j"))
103		{
104	0	jarname = args[i+1];
105	0	i++;
106		}
107	0	else if (arg.equals("-p"))
108		{
109	0	packagename = args[i+1];
110	0	i++;
111		}
112	0	else if (arg.equals("-v"))
113		{
114	0	version = args[i+1];
115	0	i++;
116		}
117	0	else if (arg.equals("-c"))
118		{
119	0	classpath = true;
120		}
121	0	else if (arg.equals("-vi"))
122		{
123	0	verifyignore = true;
124		}
125	0	else if( arg.equals("-d"))
126		{
127	0	dir = args[i+1];
128	0	i++;
129		}
130	0	else if( arg.equals("-nd"))
131		{
132	0	getdeps = false;
133		}
134	0	else if( arg.equals("-od"))
135		{
136	0	onlydeps = true;
137		}
138
139		}
140		}
141
142	0	if ( packagename == null)
143		{
144	0	System.out.println("Usage : fetch -j jarname -p package -v version ");
145	0	return;
146		}
147
148		/*
149		* now go get
150		*/
151
152		try
153		{
154		/*
155		* get the repository info
156		*/
157
158	0	Repository rep = new RepositoryXML();
159	0	rep.load( new URL( defaultRepository + "repository.xml") );
160
161		/*
162		* get the fetch target
163		*/
164
165	0	if( version == null)
166	0	version = rep.getPackageDefaultVersion( packagename );
167
168	0	System.out.println("Fetching " + packagename + " v" + version + " into file " + (jarname == null? "<default name>" : jarname ) );
169
170	0	String fetchTarget = rep.getFetchTarget( packagename, version );
171
172	0	if (fetchTarget == null)
173		{
174	0	System.out.println("JJAR.fetch : target not found for " + packagename + " v" + version );
175	0	return;
176		}
177
178		/*
179		* are there any dependencies for this fetch target?
180		*/
181
182	0	String deptarget = "";
183
184	0	if (getdeps)
185		{
186	0	List deplist = rep.getDependencyList( packagename, version );
187
188	0	Iterator ii = deplist.iterator();
189
190	0	while(ii.hasNext())
191		{
192		/*
193		* for now, use the fetchtarget names
194		*/
195
196	0	String depnameuni = (String) ii.next();
197
198	0	JJARPackage jjarp = new JJARPackage( depnameuni );
199
200	0	String depname = jjarp.getName();
201	0	String depver = jjarp.getVersionString();
202
203	0	deptarget = rep.getFetchTarget( depname, depver );
204
205	0	if( deptarget == null)
206		{
207	0	System.out.println(" Repository error : returned null for dependency " + depname + " v" + depver
208		+ " Skipping.");
209	0	continue;
210		}
211
212		/*
213		* check to see if exists if verifyignore
214		*/
215
216
217	0	if (verifyignore )
218		{
219	0	JJARPackage jpak = null;
220
221		try
222		{
223	0	jpak = ClasspathUtil.getPackage( dir + "/" + deptarget );
224		}
225	0	catch(Exception e)
226		{
227		// ignore
228	0	}
229
230	0	if (jpak != null)
231		{
232	0	if( jpak.equals( depname, depver ))
233		{
234	0	System.out.println(" Dependency '" + depname + "' exists. Skipping.");
235	0	continue;
236		}
237		}
238		}
239
240		/*
241		* now get it
242		*/
243
244	0	URL url = new URL( defaultRepository + deptarget );
245	0	URLConnection uconn = (URLConnection) url.openConnection();
246
247	0	System.out.println(" Fetching dependency : " + deptarget + " to " + dir + "/" + deptarget );
248
249	0	Transport.fetchJar( uconn, dir + "/" + deptarget );
250	0	}
251		}
252
253		/*
254		* now the actual jar. If we are told to ignore the deps, so be it
255		*/
256
257	0	if ( onlydeps )
258		{
259	0	return;
260		}
261
262		/*
263		* if verifyignore then check the jar to see if it satisfies the request
264		*/
265
266	0	if (jarname == null)
267	0	jarname = fetchTarget;
268
269	0	if( verifyignore)
270		{
271		try
272		{
273	0	JJARPackage packageinfo = ClasspathUtil.getPackage( dir + "/" + jarname );
274
275	0	if( packageinfo.equals( packagename, version ))
276		{
277	0	System.out.println("Target exists. skipping fetch");
278	0	return;
279		}
280		}
281	0	catch(Exception e)
282		{
283		// ignore and continue
284	0	}
285		}
286
287	0	URL url = new URL( defaultRepository + fetchTarget );
288	0	URLConnection uconn = (URLConnection) url.openConnection();
289
290	0	String destjar = dir + "/" + jarname;
291
292	0	System.out.println(" Fetching target : " + fetchTarget + " to " + destjar );
293
294	0	Transport.fetchJar( uconn, destjar);
295		}
296	0	catch( Exception e )
297		{
298	0	System.out.println("JJAR.fetch : exception " + e );
299	0	e.printStackTrace();
300	0	}
301	0	}
302
303		public static void verify( String args[] )
304		{
305	0	header();
306
307		/*
308		* do we do it to classpath, or was a jar specified
309		*/
310
311	0	String flag = null;
312	0	String jarname = null;
313
314	0	if (args.length > 1 )
315		{
316	0	flag = args[1];
317
318	0	if (flag.equals("-j"))
319		{
320	0	if (args.length >= 3)
321		{
322	0	jarname = args[2];
323
324		try
325		{
326	0	JJARPackage jjarp = ClasspathUtil.getPackage( jarname );
327
328	0	if (jjarp != null)
329	0	System.out.println(" " + jjarp.getName() + " v" + jjarp.getVersionString() );
330		else
331	0	System.out.println(" " + jarname + "not a jjar compatable jar");
332		}
333	0	catch( Exception e )
334		{
335	0	}
336		}
337		}
338		else
339		{
340		/*
341		* do the classpath
342		*/
343	0	List jars = ClasspathUtil.getJarList( null );
344
345	0	Iterator i = jars.iterator();
346
347	0	while( i.hasNext() )
348		{
349	0	String jar = (String) i.next();
350
351		try
352		{
353	0	JJARPackage jjarp = ClasspathUtil.getPackage( jar );
354
355	0	if (jjarp != null)
356	0	System.out.println(" " + jjarp.getName() + " v" + jjarp.getVersionString() );
357		else
358	0	System.out.println(" " + jar + "not a jjar compatable jar");
359		}
360	0	catch( Exception e )
361		{
362	0	}
363	0	}
364	0	}
365		}
366		else
367		{
368	0	System.out.println(" usage : verify -c \| -j jarname");
369		}
370	0	return;
371		}
372
373		public static void list( String args[] )
374		{
375	0	header();
376
377		try
378		{
379	0	URL url = new URL(defaultRepository + "repository.xml");
380
381	0	Repository rep = new RepositoryXML();
382	0	rep.load(url);
383
384	0	if (args.length >= 3 )
385		{
386	0	String flag = args[1];
387
388	0	if (flag.equals("-p"))
389		{
390	0	String pkg = args[2];
391
392	0	dumpInfo( rep, pkg );
393		}
394	0	}
395		else
396		{
397	0	System.out.println("Repository contains " + rep.getPackageCount() + " packages : " );
398
399	0	Iterator i = rep.getPackageListIter();
400
401	0	while( i.hasNext() )
402		{
403	0	String p = (String) i.next();
404	0	dumpInfo( rep, p );
405	0	System.out.println("");
406	0	}
407		}
408		}
409	0	catch( Exception e )
410		{
411	0	System.out.println("JJAR.list : exception " + e );
412	0	e.printStackTrace();
413	0	}
414	0	}
415
416		private static void dumpInfo(Repository rep, String p )
417		{
418	0	System.out.println(" " + p );
419	0	System.out.println(" desc : " + rep.getPackageDescription( p ) );
420	0	System.out.println(" default : " + rep.getPackageDefaultVersion( p ));
421	0	System.out.println(" versions : ");
422
423	0	List l = rep.getPackageVersionList( p );
424
425	0	Iterator ii = l.iterator();
426
427	0	while( ii.hasNext() )
428		{
429	0	String version = (String) ii.next() ;
430
431	0	System.out.print( " " + version + " deps : " );
432
433	0	List depl = rep.getDependencyList( p, version );
434
435	0	Iterator iii = depl.iterator();
436
437	0	while( iii.hasNext() )
438		{
439	0	System.out.print( iii.next() + ", " );
440		}
441
442	0	System.out.println("");
443	0	}
444
445	0	System.out.println("--");
446
447	0	}
448
449		public static void mark( String args[] )
450		{
451		// mark -j jarname -p package -v version
452
453	0	String packagename = null;
454	0	String jarname = null;
455	0	String version = null;
456
457	0	if ( args.length < 7 )
458		{
459	0	System.out.println("Usage : mark -j jarname -p package -v version ");
460	0	return;
461		}
462
463	0	for( int i = 1; i < args.length; i++)
464		{
465	0	String arg = args[i];
466
467	0	if (arg.startsWith("-"))
468		{
469	0	if (arg.equals("-j"))
470		{
471	0	jarname = args[i+1];
472	0	i++;
473		}
474	0	else if (arg.equals("-p"))
475		{
476	0	packagename = args[i+1];
477	0	i++;
478		}
479	0	else if (arg.equals("-v"))
480		{
481	0	version = args[i+1];
482	0	i++;
483		}
484
485		}
486		}
487
488	0	if ( packagename == null \|\| jarname == null \|\| version == null)
489		{
490	0	System.out.println("Usage : mark -j jarname -p package -v version ");
491	0	return;
492		}
493
494		try
495		{
496	0	if (ClasspathUtil.markJar( jarname, packagename, version ))
497	0	System.out.println("successful");
498
499		}
500	0	catch( Exception e)
501		{
502	0	System.out.println("Exception e : " + e );
503	0	}
504
505	0	}
506
507		private static void header()
508		{
509	0	System.out.println(title);
510	0	System.out.println(" - using repository " + defaultRepository);
511	0	System.out.println("---------------------------------------------");
512	0	System.out.println("");
513	0	}
514		}