Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
TransRepRule	19	4	4	0.00%	Show methods
Transformer	63	42	27	0.00%	Show methods

Class TransRepRule

Class TransRepRule	Line # 19	Total Statements 4	Complexity 4	TOTAL Coverage 0.00%
TransRepRule(Transformer)   TransRepRule(Transformer)	2323	1.01	1.01	0.0 0.00%
toString1() : String   toString1() : String	2828	1.01	1.01	0.0 0.00%
clone1() : Object   clone1() : Object	3333	1.01	1.01	0.0 0.00%
apply(StringBufferLike,RegRes) : void   apply(StringBufferLike,RegRes) : void	3838	1.01	1.01	0.0 0.00%

 

Class Transformer

Class Transformer	Line # 63	Total Statements 42	Complexity 27	TOTAL Coverage 0.00%
getReplacer() : Replacer   getReplacer() : Replacer	7676	1.01	1.01	0.0 0.00%
Transformer(boolean)   Transformer(boolean)	8282	4.04	1.01	0.0 0.00%
add(Regex) : void   add(Regex) : void	9191	9.09	5.05	0.0 0.00%
patterns() : int   patterns() : int	111111	1.01	1.01	0.0 0.00%
getRegexAt(int) : Regex   getRegexAt(int) : Regex	117117	5.05	3.03	0.0 0.00%
setRegexAt(Regex,int) : void   setRegexAt(Regex,int) : void	131131	5.05	3.03	0.0 0.00%
add(String) : void   add(String) : void	149149	4.04	2.02	0.0 0.00%
add(String[]) : void   add(String[]) : void	167167	2.02	2.02	0.0 0.00%
replaceAll(String) : String   replaceAll(String) : String	176176	1.01	1.01	0.0 0.00%
replaceAll(StringLike) : StringLike   replaceAll(StringLike) : StringLike	181181	1.01	1.01	0.0 0.00%
replaceAllFrom(String,int) : String   replaceAllFrom(String,int) : String	187187	1.01	1.01	0.0 0.00%
replaceAllRegion(String,int,int) : String   replaceAllRegion(String,int,int) : String	196196	1.01	1.01	0.0 0.00%
dorep(StringLike,int,int) : StringLike   dorep(StringLike,int,int) : StringLike	203203	3.03	1.01	0.0 0.00%
dorep(String,int,int) : String   dorep(String,int,int) : String	210210	1.01	1.01	0.0 0.00%
replaceFirst(String) : String   replaceFirst(String) : String	216216	1.01	1.01	0.0 0.00%
replaceFirstFrom(String,int) : String   replaceFirstFrom(String,int) : String	224224	1.01	1.01	0.0 0.00%
replaceFirstRegion(String,int,int) : String   replaceFirstRegion(String,int,int) : String	233233	1.01	1.01	0.0 0.00%

 

Contributing tests

Source view

1		//
2		// This software is now distributed according to
3		// the Lesser Gnu Public License. Please see
4		// http://www.gnu.org/copyleft/lesser.txt for
5		// the details.
6		// -- Happy Computing!
7		//
8		package com.stevesoft.pat;
9
10		import jalview.util.MessageManager;
11
12		import com.stevesoft.pat.wrap.StringWrap;
13
14		/**
15		* Replacement rule used by the Transformer.
16		*
17		* @see com.stevesoft.pat.Transformer
18		*/
		0% Uncovered Elements: 8 (8) Complexity: 4 Complexity Density: 1
19		class TransRepRule extends ReplaceRule
20		{
21		Transformer t;
22
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
23	0	TransRepRule(Transformer t)...
24		{
25	0	this.t = t;
26		}
27
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
28	0	public String toString1()...
29		{
30	0	return "";
31		}
32
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
33	0	public Object clone1()...
34		{
35	0	return new TransRepRule(t);
36		}
37
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
38	0	public void apply(StringBufferLike sb, RegRes rr)...
39		{
40		// get the ReplaceRule of the Regex that matched.
41	0	next = t.tp.ra[t.tp.pn].getReplaceRule();
42		}
43		}
44
45		/**
46		* Sometimes you want to replace a whole bunch of things that might occur within
47		* a single line of text. One efficient way to do this, both in terms of
48		* performance and programming ease, is with Transformer. The Transformer
49		* contains an array of Regex's and uses the Regex that matches earliest within
50		* the text to do the replacing, if two Regex's match at the same time it uses
51		* the one put in the Transformer first.
52		* <p>
53		* This feature can be used to prevent transformations from occurring in certain
54		* regions. For example, if I add the rule s'//.*'$&' and then add the rule
55		* s/hello/goodbye/ the Transformer will replace "hello" with "goodbye" except
56		* when it occurs inside a double-slash style of comment. The transformation on
57		* the comment goes first, does nothing, and precludes transformation on the
58		* same region of text as the s/hello/goodbye/ rule.
59		* <p>
60		* So far, at least, this class does not have the capability of turning into a
61		* giant robot :-)
62		*/
		0% Uncovered Elements: 79 (79) Complexity: 27 Complexity Density: 0.64
63		public class Transformer
64		{
65		TransPat tp;
66
67		Regex rp = new Regex();
68
69		boolean auto_optimize;
70
71		/**
72		* Get a replacer to that works with the current Regex.
73		*
74		* @see com.stevesoft.pat.Replacer
75		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
76	0	public Replacer getReplacer()...
77		{
78	0	return rp.getReplacer();
79		}
80
81		/** Instantiate a new Transformer object. */
		0% Uncovered Elements: 4 (4) Complexity: 1 Complexity Density: 0.25
82	0	public Transformer(boolean auto)...
83		{
84	0	auto_optimize = auto;
85	0	tp = new TransPat();
86	0	rp.setReplaceRule(new TransRepRule(this));
87	0	rp.thePattern = tp;
88		}
89
90		/** Add a new Regex to the set of Regex's. */
		0% Uncovered Elements: 17 (17) Complexity: 5 Complexity Density: 0.56
91	0	public void add(Regex r)...
92		{
93	0	if (auto_optimize)
94		{
95	0	r.optimize();
96		}
97	0	tp.ra[tp.ra_len++] = r;
98	0	if (tp.ra.length == tp.ra_len)
99		{
100	0	Regex[] ra2 = new Regex[tp.ra_len + 10];
101	0	for (int i = 0; i < tp.ra_len; i++)
102		{
103	0	ra2[i] = tp.ra[i];
104		}
105	0	tp.ra = ra2;
106		}
107	0	rp.numSubs_ = r.numSubs_ > rp.numSubs_ ? r.numSubs_ : rp.numSubs_;
108		}
109
110		/** Returns the number of Regex's in this Transformer. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
111	0	public int patterns()...
112		{
113	0	return tp.ra_len;
114		}
115
116		/** Get the Regex at position i in this Transformer. */
		0% Uncovered Elements: 9 (9) Complexity: 3 Complexity Density: 0.6
117	0	public Regex getRegexAt(int i)...
118		{
119	0	if (i >= tp.ra_len)
120		{
121	0	throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
122		}
123	0	if (i < 0)
124		{
125	0	throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
126		}
127	0	return tp.ra[i];
128		}
129
130		/** Set the Regex at position i in this Transformer. */
		0% Uncovered Elements: 9 (9) Complexity: 3 Complexity Density: 0.6
131	0	public void setRegexAt(Regex rx, int i)...
132		{
133	0	if (i >= tp.ra_len)
134		{
135	0	throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
136		}
137	0	if (i < 0)
138		{
139	0	throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
140		}
141	0	tp.ra[i] = rx;
142		}
143
144		/**
145		* Add a new Regex by calling Regex.perlCode
146		*
147		* @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
148		*/
		0% Uncovered Elements: 6 (6) Complexity: 2 Complexity Density: 0.5
149	0	public void add(String rs)...
150		{
151	0	Regex r = Regex.perlCode(rs);
152	0	if (r == null)
153		{
154	0	throw new NullPointerException(MessageManager.formatMessage(
155		"exception.bad_pattern_to_regex_perl_code",
156		new String[] { rs }));
157		}
158	0	add(r);
159		}
160
161		/**
162		* Add an array of Strings (which will be converted to Regex's via the
163		* Regex.perlCode method.
164		*
165		* @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
166		*/
		0% Uncovered Elements: 4 (4) Complexity: 2 Complexity Density: 1
167	0	public void add(String[] array)...
168		{
169	0	for (int i = 0; i < array.length; i++)
170		{
171	0	add(array[i]);
172		}
173		}
174
175		/** Replace all matches in the current String. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
176	0	public String replaceAll(String s)...
177		{
178	0	return dorep(s, 0, s.length());
179		}
180
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
181	0	public StringLike replaceAll(StringLike s)...
182		{
183	0	return dorep(s, 0, s.length());
184		}
185
186		/** Replace all matching patterns beginning at position start. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
187	0	public String replaceAllFrom(String s, int start)...
188		{
189	0	return dorep(s, start, s.length());
190		}
191
192		/**
193		* Replace all matching patterns beginning between the positions start and end
194		* inclusive.
195		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
196	0	public String replaceAllRegion(String s, int start, int end)...
197		{
198	0	return dorep(s, start, end);
199		}
200
201		Replacer repr = new Replacer();
202
		0% Uncovered Elements: 3 (3) Complexity: 1 Complexity Density: 0.33
203	0	final StringLike dorep(StringLike s, int start, int end)...
204		{
205	0	StringLike tfmd = repr.replaceAllRegion(s, rp, start, end);
206	0	tp.lastMatchedTo = repr.lastMatchedTo;
207	0	return tfmd;
208		}
209
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
210	0	final String dorep(String s, int start, int end)...
211		{
212	0	return dorep(new StringWrap(s), start, end).toString();
213		}
214
215		/** Replace the first matching pattern in String s. */
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
216	0	public String replaceFirst(String s)...
217		{
218	0	return dorep(s, 0, s.length());
219		}
220
221		/**
222		* Replace the first matching pattern after position start in String s.
223		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
224	0	public String replaceFirstFrom(String s, int start)...
225		{
226	0	return dorep(s, start, s.length());
227		}
228
229		/**
230		* Replace the first matching pattern that begins between start and end
231		* inclusive.
232		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
233	0	public String replaceFirstRegion(String s, int start, int end)...
234		{
235	0	return dorep(s, start, end);
236		}
237		}