Coverage Report

Coverage Report - org.seasar.uruma.util.PathUtil

Classes in this File

Line Coverage

Branch Coverage

Complexity

PathUtil

95%

42/44

100%

28/28

3.5

 /*
  * Copyright 2004-2008 the Seasar Foundation and the Others.
  *
  * 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.seasar.uruma.util;
 
 import org.seasar.framework.util.StringUtil;
 
 /**
  * パスに関するユーティリティメソッドを提供するクラスです。<br />
  * 
  * @author y-komori
  */
 public class PathUtil {
     private PathUtil() {
 
     }
 
     private static final String YEN_SIGN = "\\";
 
     private static final String SLASH = "/";
 
     private static final char SLASH_CHAR = '/';
 
     private static final String PERIOD = ".";
 
     private static final String NULL_STRING = "";
 
     /**
      * 与えられた基準パスと相対パスから絶対パスを生成します。</br>
      * <ul>
      * <li>パス中の <code>\</code> はすべて <code>/</code> に変換します。
      * <li>基本動作として <code>basePath</code> と <code>relPath</code>
      * を連結した文字列を返します。
      * <li>この際、<code>basePath</code> が <code>/</code> で終了していない場合、<code>/</code>
      * を付加します。
      * <li><code>relPath</code> が <code>/</code> から始まる場合、<code>relPath</code>
      * が絶対パスを表していると見なして、<code>basePath</code> は無視されます。
      * <li><code>basePath</code> が <code>relPath</code> の先頭に含まれる場合、<code>basePath</code>
      * は無視されます。
      * </ul>
      * 
      * @param basePath
      *            基準パス
      * @param relPath
      *            相対パス
      * @return 生成したパス
      */
     public static String createPath(String basePath, String relPath) {
         basePath = replaceSeparator(basePath);
         relPath = replaceSeparator(relPath);
         String path = "";
         if (relPath.charAt(0) == SLASH_CHAR) {
             basePath = NULL_STRING;
         }
         if (!StringUtil.isEmpty(basePath)) {
             if (!relPath.startsWith(basePath)) {
                 path += basePath;
                 if (!path.endsWith(SLASH)) {
                     path += SLASH;
                 }
             }
         }
         path += relPath;
         return path;
     }
 
     /**
      * セパレータを「\」から「/」へ変換します。<br />
      * 
      * @param path
      *            パス
      * @return 変換後のパス
      */
     public static String replaceSeparator(final String path) {
         if (path != null) {
             return StringUtil.replace(path, YEN_SIGN, SLASH);
         } else {
             return NULL_STRING;
         }
     }
 
     /**
      * 与えられたパスのベースパスを基準とした相対パスを返します。<br />
      * 
      * @param basePath
      *            ベースパス
      * @param path
      *            パス
      */
     public static String getRelativePath(final String basePath,
             final String path) {
         AssertionUtil.assertNotNull("basePath", basePath);
         AssertionUtil.assertNotNull("path", path);
 
         if (path.startsWith(basePath)) {
             return path.substring(basePath.length(), path.length());
         } else {
             return path;
         }
     }
 
     /**
      * 指定されたパスの親ディレクトリ部分を返します。<br />
      * セパレータは \ と / の両方を認識します。<br />
      * 混在している場合は、より後ろの方を区切りとします。<br />
      * 
      * @param path
      *            パス
      * @return 親ディレクトリ部分
      */
     public static String getParent(final String path) {
         if (path != null) {
             int slashIndex = path.lastIndexOf(SLASH);
             int yenIndex = path.lastIndexOf(YEN_SIGN);
             int pos = (slashIndex > yenIndex) ? slashIndex : yenIndex;
             if (pos >= 0) {
                 return path.substring(0, pos);
             } else {
                 return path;
             }
         } else {
             return null;
         }
     }
 
     /**
      * 指定されたパスのファイル名部分を返します。<br />
      * セパレータは \ と / の両方を認識します。<br />
      * 混在している場合は、より後ろの方を区切りとします。<br />
      * 
      * @param path
      *            パス
      * @return ファイル名部分
      */
     public static String getFileName(final String path) {
         if (path != null) {
             int slashIndex = path.lastIndexOf(SLASH);
             int yenIndex = path.lastIndexOf(YEN_SIGN);
             int pos = (slashIndex > yenIndex) ? slashIndex : yenIndex;
             return path.substring(pos + 1, path.length());
         } else {
             return null;
         }
     }
 
     /**
      * ファイル名から拡張子を除いた部分を返します。<br />
      * 
      * @param fileName
      *            フィル名
      * @return 拡張子を除いた部分
      */
     public static String getBaseName(final String fileName) {
         if (fileName != null) {
             return StringUtil.substringFromLast(fileName, PERIOD);
         } else {
             return null;
         }
     }
 
     /**
      * パスの拡張子の部分(最後に登場するピリオド以降)を返します。<br />
      * 
      * @param path
      *            パス
      * @return 拡張子
      */
     public static String getExt(final String path) {
         if (path != null) {
             if (path.indexOf(PERIOD) > 0) {
                 return StringUtil.substringToLast(path, PERIOD);
             } else {
                 return NULL_STRING;
             }
         } else {
             return null;
         }
     }
 }

1		/*
2		* Copyright 2004-2008 the Seasar Foundation and the Others.
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,
13		* either express or implied. See the License for the specific language
14		* governing permissions and limitations under the License.
15		*/
16		package org.seasar.uruma.util;
17
18		import org.seasar.framework.util.StringUtil;
19
20		/**
21		* パスに関するユーティリティメソッドを提供するクラスです。<br />
22		*
23		* @author y-komori
24		*/
25		public class PathUtil {
26	0	private PathUtil() {
27
28	0	}
29
30		private static final String YEN_SIGN = "\\";
31
32		private static final String SLASH = "/";
33
34		private static final char SLASH_CHAR = '/';
35
36		private static final String PERIOD = ".";
37
38		private static final String NULL_STRING = "";
39
40		/**
41		* 与えられた基準パスと相対パスから絶対パスを生成します。</br>
42		* <ul>
43		* <li>パス中の <code>\</code> はすべて <code>/</code> に変換します。
44		* <li>基本動作として <code>basePath</code> と <code>relPath</code>
45		* を連結した文字列を返します。
46		* <li>この際、<code>basePath</code> が <code>/</code> で終了していない場合、<code>/</code>
47		* を付加します。
48		* <li><code>relPath</code> が <code>/</code> から始まる場合、<code>relPath</code>
49		* が絶対パスを表していると見なして、<code>basePath</code> は無視されます。
50		* <li><code>basePath</code> が <code>relPath</code> の先頭に含まれる場合、<code>basePath</code>
51		* は無視されます。
52		* </ul>
53		*
54		* @param basePath
55		* 基準パス
56		* @param relPath
57		* 相対パス
58		* @return 生成したパス
59		*/
60		public static String createPath(String basePath, String relPath) {
61	92	basePath = replaceSeparator(basePath);
62	92	relPath = replaceSeparator(relPath);
63	92	String path = "";
64	92	if (relPath.charAt(0) == SLASH_CHAR) {
65	64	basePath = NULL_STRING;
66		}
67	92	if (!StringUtil.isEmpty(basePath)) {
68	24	if (!relPath.startsWith(basePath)) {
69	20	path += basePath;
70	20	if (!path.endsWith(SLASH)) {
71	16	path += SLASH;
72		}
73		}
74		}
75	92	path += relPath;
76	92	return path;
77		}
78
79		/**
80		* セパレータを「\」から「/」へ変換します。<br />
81		*
82		* @param path
83		* パス
84		* @return 変換後のパス
85		*/
86		public static String replaceSeparator(final String path) {
87	192	if (path != null) {
88	188	return StringUtil.replace(path, YEN_SIGN, SLASH);
89		} else {
90	4	return NULL_STRING;
91		}
92		}
93
94		/**
95		* 与えられたパスのベースパスを基準とした相対パスを返します。<br />
96		*
97		* @param basePath
98		* ベースパス
99		* @param path
100		* パス
101		*/
102		public static String getRelativePath(final String basePath,
103		final String path) {
104	20	AssertionUtil.assertNotNull("basePath", basePath);
105	16	AssertionUtil.assertNotNull("path", path);
106
107	12	if (path.startsWith(basePath)) {
108	8	return path.substring(basePath.length(), path.length());
109		} else {
110	4	return path;
111		}
112		}
113
114		/**
115		* 指定されたパスの親ディレクトリ部分を返します。<br />
116		* セパレータは \ と / の両方を認識します。<br />
117		* 混在している場合は、より後ろの方を区切りとします。<br />
118		*
119		* @param path
120		* パス
121		* @return 親ディレクトリ部分
122		*/
123		public static String getParent(final String path) {
124	32	if (path != null) {
125	28	int slashIndex = path.lastIndexOf(SLASH);
126	28	int yenIndex = path.lastIndexOf(YEN_SIGN);
127	28	int pos = (slashIndex > yenIndex) ? slashIndex : yenIndex;
128	28	if (pos >= 0) {
129	24	return path.substring(0, pos);
130		} else {
131	4	return path;
132		}
133		} else {
134	4	return null;
135		}
136		}
137
138		/**
139		* 指定されたパスのファイル名部分を返します。<br />
140		* セパレータは \ と / の両方を認識します。<br />
141		* 混在している場合は、より後ろの方を区切りとします。<br />
142		*
143		* @param path
144		* パス
145		* @return ファイル名部分
146		*/
147		public static String getFileName(final String path) {
148	256	if (path != null) {
149	252	int slashIndex = path.lastIndexOf(SLASH);
150	252	int yenIndex = path.lastIndexOf(YEN_SIGN);
151	252	int pos = (slashIndex > yenIndex) ? slashIndex : yenIndex;
152	252	return path.substring(pos + 1, path.length());
153		} else {
154	4	return null;
155		}
156		}
157
158		/**
159		* ファイル名から拡張子を除いた部分を返します。<br />
160		*
161		* @param fileName
162		* フィル名
163		* @return 拡張子を除いた部分
164		*/
165		public static String getBaseName(final String fileName) {
166	244	if (fileName != null) {
167	240	return StringUtil.substringFromLast(fileName, PERIOD);
168		} else {
169	4	return null;
170		}
171		}
172
173		/**
174		* パスの拡張子の部分(最後に登場するピリオド以降)を返します。<br />
175		*
176		* @param path
177		* パス
178		* @return 拡張子
179		*/
180		public static String getExt(final String path) {
181	20	if (path != null) {
182	16	if (path.indexOf(PERIOD) > 0) {
183	8	return StringUtil.substringToLast(path, PERIOD);
184		} else {
185	8	return NULL_STRING;
186		}
187		} else {
188	4	return null;
189		}
190		}
191		}