Coverage Report

Coverage Report - org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository

Classes in this File

Line Coverage

Branch Coverage

Complexity

SvnScmProviderRepository

88 %

63/71

79 %

27/34

2,538

 package org.apache.maven.scm.provider.svn.repository;
 
 /*
  * 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 org.apache.maven.scm.provider.ScmProviderRepository;
 import org.apache.maven.scm.provider.ScmProviderRepositoryWithHost;
 import org.apache.maven.scm.provider.svn.SvnTagBranchUtils;
 
 /**
  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
  * @version $Id: SvnScmProviderRepository.java 1241178 2012-02-06 21:04:41Z rfscholte $
  */
 public class SvnScmProviderRepository
     extends ScmProviderRepositoryWithHost
 {
     /** */
     private String url;
 
     private String protocol;
 
     /**
      * The base directory for any tags. Can be relative to the repository URL or an absolute URL.
      */
     private String tagBase;
 
     /**
      * The base directory for any branches. Can be relative to the repository URL or an absolute URL.
      */
     private String branchBase;
 
     public SvnScmProviderRepository( String url )
     {
         parseUrl( url );
 
         tagBase = SvnTagBranchUtils.resolveTagBase( url );
 
         branchBase = SvnTagBranchUtils.resolveBranchBase( url );
     }
 
     public SvnScmProviderRepository( String url, String user, String password )
     {
         this( url );
 
         setUser( user );
 
         setPassword( password );
     }
 
     public String getUrl()
     {
         return url;
     }
 
     /**
      * Returns the url/directory to be used when tagging this repository.
      */
     public String getTagBase()
     {
         return tagBase;
     }
 
     /**
      * Sets the url/directory to be used when tagging this repository.
      * The TagBase is a way to override the default tag location for the
      * repository.  The default tag location is automatically determined
      * for repositories in the standard subversion layout (with /tags /branches /trunk).
      * Specify this value only if the repository is using a directory other than "/tags" for tagging.
      *
      * @param tagBase an absolute or relative url to the base directory to create tags in.
      *                URL should be in a format that svn client understands, not the scm url format.
      */
     public void setTagBase( String tagBase )
     {
         this.tagBase = tagBase;
     }
 
     /**
      * Returns the url/directory to be used when tagging this repository.
      */
     public String getBranchBase()
     {
         return branchBase;
     }
 
     /**
      * Sets the url/directory to be used when branching this repository.
      * The BranchBase is a way to override the default branch location for the
      * repository.  The default branch location is automatically determined
      * for repositories in the standard subversion layout (with /tags /branches /trunk).
      * Specify this value only if the repository is using a directory other than "/branches" for branching.
      *
      * @param branchBase an absolute or relative url to the base directory to create branch in.
      *                   URL should be in a format that svn client understands, not the scm url format.
      */
     public void setBranchBase( String branchBase )
     {
         this.branchBase = branchBase;
     }
 
     private void setProtocol( String protocol )
     {
         this.protocol = protocol;
     }
 
     /**
      * Get the protocol used in this repository (file://, http://, https://,...)
      *
      * @return the protocol
      */
     public String getProtocol()
     {
         return protocol;
     }
 
     private void parseUrl( String url )
     {
         if ( url.startsWith( "file" ) )
         {
             setProtocol( "file://" );
         }
         else if ( url.startsWith( "https" ) )
         {
             setProtocol( "https://" );
         }
         else if ( url.startsWith( "http" ) )
         {
             setProtocol( "http://" );
         }
         else if ( url.startsWith( "svn+" ) )
         {
             setProtocol( url.substring( 0, url.indexOf( "://" ) + 3 ) );
         }
         else if ( url.startsWith( "svn" ) )
         {
             setProtocol( "svn://" );
         }
 
         if ( getProtocol() == null )
         {
             return;
         }
 
         String urlPath = url.substring( getProtocol().length() );
 
         int indexAt = urlPath.indexOf( '@' );
 
         if ( indexAt > 0 && !getProtocol().startsWith( "svn+" ) )
         {
             String userPassword = urlPath.substring( 0, indexAt );
             if ( userPassword.indexOf( ':' ) < 0 )
             {
                 setUser( userPassword );
             }
             else
             {
                 setUser( userPassword.substring( 0, userPassword.indexOf( ':' ) ) );
                 setPassword( userPassword.substring( userPassword.indexOf( ':' ) + 1 ) );
             }
 
             urlPath = urlPath.substring( indexAt + 1 );
 
             this.url = getProtocol() + urlPath;
         }
         else
         {
             this.url = getProtocol() + urlPath;
         }
 
         if ( !"file://".equals( getProtocol() ) )
         {
             int indexSlash = urlPath.indexOf( '/' );
 
             String hostPort = urlPath;
 
             if ( indexSlash > 0 )
             {
                 hostPort = urlPath.substring( 0, indexSlash );
             }
 
             int indexColon = hostPort.indexOf( ':' );
 
             if ( indexColon > 0 )
             {
                 setHost( hostPort.substring( 0, indexColon ) );
                 setPort( Integer.parseInt( hostPort.substring( indexColon + 1 ) ) );
             }
             else
             {
                 setHost( hostPort );
             }
         }
     }
 
     /** {@inheritDoc} */
     public ScmProviderRepository getParent()
     {
         String newUrl = getUrl().substring( getProtocol().length() );
 
         while ( newUrl.endsWith( "/." ) )
         {
             newUrl = newUrl.substring( 0, newUrl.length() - 2 );
         }
 
         while ( newUrl.endsWith( "/" ) )
         {
             newUrl = newUrl.substring( 0, newUrl.length() - 1 );
         }
 
         int i = newUrl.lastIndexOf( '/' );
 
         if ( i < 0 )
         {
             return null;
         }
         newUrl = newUrl.substring( 0, i );
 
         return new SvnScmProviderRepository( getProtocol() + newUrl, getUser(), getPassword() );
     }
 
     /** {@inheritDoc} */
     public String getRelativePath( ScmProviderRepository ancestor )
     {
         if ( ancestor instanceof SvnScmProviderRepository )
         {
             SvnScmProviderRepository svnAncestor = (SvnScmProviderRepository) ancestor;
 
             String path = getUrl().replaceFirst( svnAncestor.getUrl() + "/", "" );
 
             if ( !path.equals( getUrl() ) )
             {
                 return path;
             }
         }
         return null;
     }
 
     /** {@inheritDoc} */
     public String toString()
     {
         return getUrl();
     }
 
 }

1		package org.apache.maven.scm.provider.svn.repository;
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 org.apache.maven.scm.provider.ScmProviderRepository;
23		import org.apache.maven.scm.provider.ScmProviderRepositoryWithHost;
24		import org.apache.maven.scm.provider.svn.SvnTagBranchUtils;
25
26		/**
27		* @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
28		* @version $Id: SvnScmProviderRepository.java 1241178 2012-02-06 21:04:41Z rfscholte $
29		*/
30		public class SvnScmProviderRepository
31		extends ScmProviderRepositoryWithHost
32		{
33		/** */
34		private String url;
35
36		private String protocol;
37
38		/**
39		* The base directory for any tags. Can be relative to the repository URL or an absolute URL.
40		*/
41		private String tagBase;
42
43		/**
44		* The base directory for any branches. Can be relative to the repository URL or an absolute URL.
45		*/
46		private String branchBase;
47
48		public SvnScmProviderRepository( String url )
49	68	{
50	68	parseUrl( url );
51
52	68	tagBase = SvnTagBranchUtils.resolveTagBase( url );
53
54	68	branchBase = SvnTagBranchUtils.resolveBranchBase( url );
55	68	}
56
57		public SvnScmProviderRepository( String url, String user, String password )
58		{
59	4	this( url );
60
61	4	setUser( user );
62
63	4	setPassword( password );
64	4	}
65
66		public String getUrl()
67		{
68	107	return url;
69		}
70
71		/**
72		* Returns the url/directory to be used when tagging this repository.
73		*/
74		public String getTagBase()
75		{
76	37	return tagBase;
77		}
78
79		/**
80		* Sets the url/directory to be used when tagging this repository.
81		* The TagBase is a way to override the default tag location for the
82		* repository. The default tag location is automatically determined
83		* for repositories in the standard subversion layout (with /tags /branches /trunk).
84		* Specify this value only if the repository is using a directory other than "/tags" for tagging.
85		*
86		* @param tagBase an absolute or relative url to the base directory to create tags in.
87		* URL should be in a format that svn client understands, not the scm url format.
88		*/
89		public void setTagBase( String tagBase )
90		{
91	2	this.tagBase = tagBase;
92	2	}
93
94		/**
95		* Returns the url/directory to be used when tagging this repository.
96		*/
97		public String getBranchBase()
98		{
99	18	return branchBase;
100		}
101
102		/**
103		* Sets the url/directory to be used when branching this repository.
104		* The BranchBase is a way to override the default branch location for the
105		* repository. The default branch location is automatically determined
106		* for repositories in the standard subversion layout (with /tags /branches /trunk).
107		* Specify this value only if the repository is using a directory other than "/branches" for branching.
108		*
109		* @param branchBase an absolute or relative url to the base directory to create branch in.
110		* URL should be in a format that svn client understands, not the scm url format.
111		*/
112		public void setBranchBase( String branchBase )
113		{
114	3	this.branchBase = branchBase;
115	3	}
116
117		private void setProtocol( String protocol )
118		{
119	68	this.protocol = protocol;
120	68	}
121
122		/**
123		* Get the protocol used in this repository (file://, http://, https://,...)
124		*
125		* @return the protocol
126		*/
127		public String getProtocol()
128		{
129	291	return protocol;
130		}
131
132		private void parseUrl( String url )
133		{
134	68	if ( url.startsWith( "file" ) )
135		{
136	10	setProtocol( "file://" );
137		}
138	58	else if ( url.startsWith( "https" ) )
139		{
140	5	setProtocol( "https://" );
141		}
142	53	else if ( url.startsWith( "http" ) )
143		{
144	42	setProtocol( "http://" );
145		}
146	11	else if ( url.startsWith( "svn+" ) )
147		{
148	7	setProtocol( url.substring( 0, url.indexOf( "://" ) + 3 ) );
149		}
150	4	else if ( url.startsWith( "svn" ) )
151		{
152	4	setProtocol( "svn://" );
153		}
154
155	68	if ( getProtocol() == null )
156		{
157	0	return;
158		}
159
160	68	String urlPath = url.substring( getProtocol().length() );
161
162	68	int indexAt = urlPath.indexOf( '@' );
163
164	68	if ( indexAt > 0 && !getProtocol().startsWith( "svn+" ) )
165		{
166	9	String userPassword = urlPath.substring( 0, indexAt );
167	9	if ( userPassword.indexOf( ':' ) < 0 )
168		{
169	6	setUser( userPassword );
170		}
171		else
172		{
173	3	setUser( userPassword.substring( 0, userPassword.indexOf( ':' ) ) );
174	3	setPassword( userPassword.substring( userPassword.indexOf( ':' ) + 1 ) );
175		}
176
177	9	urlPath = urlPath.substring( indexAt + 1 );
178
179	9	this.url = getProtocol() + urlPath;
180	9	}
181		else
182		{
183	59	this.url = getProtocol() + urlPath;
184		}
185
186	68	if ( !"file://".equals( getProtocol() ) )
187		{
188	58	int indexSlash = urlPath.indexOf( '/' );
189
190	58	String hostPort = urlPath;
191
192	58	if ( indexSlash > 0 )
193		{
194	46	hostPort = urlPath.substring( 0, indexSlash );
195		}
196
197	58	int indexColon = hostPort.indexOf( ':' );
198
199	58	if ( indexColon > 0 )
200		{
201	4	setHost( hostPort.substring( 0, indexColon ) );
202	4	setPort( Integer.parseInt( hostPort.substring( indexColon + 1 ) ) );
203		}
204		else
205		{
206	54	setHost( hostPort );
207		}
208		}
209	68	}
210
211		/** {@inheritDoc} */
212		public ScmProviderRepository getParent()
213		{
214	4	String newUrl = getUrl().substring( getProtocol().length() );
215
216	10	while ( newUrl.endsWith( "/." ) )
217		{
218	6	newUrl = newUrl.substring( 0, newUrl.length() - 2 );
219		}
220
221	10	while ( newUrl.endsWith( "/" ) )
222		{
223	6	newUrl = newUrl.substring( 0, newUrl.length() - 1 );
224		}
225
226	4	int i = newUrl.lastIndexOf( '/' );
227
228	4	if ( i < 0 )
229		{
230	0	return null;
231		}
232	4	newUrl = newUrl.substring( 0, i );
233
234	4	return new SvnScmProviderRepository( getProtocol() + newUrl, getUser(), getPassword() );
235		}
236
237		/** {@inheritDoc} */
238		public String getRelativePath( ScmProviderRepository ancestor )
239		{
240	0	if ( ancestor instanceof SvnScmProviderRepository )
241		{
242	0	SvnScmProviderRepository svnAncestor = (SvnScmProviderRepository) ancestor;
243
244	0	String path = getUrl().replaceFirst( svnAncestor.getUrl() + "/", "" );
245
246	0	if ( !path.equals( getUrl() ) )
247		{
248	0	return path;
249		}
250		}
251	0	return null;
252		}
253
254		/** {@inheritDoc} */
255		public String toString()
256		{
257	18	return getUrl();
258		}
259
260		}