Coverage Report

Coverage Report - org.ini4j.IniParser

Classes in this File

Line Coverage

Branch Coverage

Complexity

IniParser

100%

48/48

100%

20/20

IniParser$1XmlToIni

100%

21/21

100%

16/16

 /*
  * Copyright 2005,2009 Ivan SZKIBA
  *
  * 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.ini4j;
 
 import org.ini4j.spi.ServiceFinder;
 
 import org.xml.sax.Attributes;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 
 import java.net.URL;
 
 import java.util.Locale;
 
 import javax.xml.parsers.SAXParserFactory;
 
 public class IniParser extends AbstractParser
 {
     private static final String COMMENTS = ";#";
     private static final String OPERATORS = ":=";
 
     public static final char SECTION_BEGIN = '[';
     public static final char SECTION_END = ']';
 
     public IniParser()
     {
         super(OPERATORS, COMMENTS);
     }
 
     public static IniParser newInstance()
     {
         return ServiceFinder.findService(IniParser.class);
     }
 
     public static IniParser newInstance(Config config)
     {
         IniParser instance = newInstance();
 
         instance.setConfig(config);
 
         return instance;
     }
 
     public void parse(InputStream input, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         parse(newIniSource(input), handler);
     }
 
     public void parse(Reader input, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         parse(newIniSource(input), handler);
     }
 
     public void parse(URL input, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         parse(newIniSource(input), handler);
     }
 
     public void parseXML(InputStream input, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         parseXML(new InputStreamReader(input), handler);
     }
 
     public void parseXML(Reader input, final IniHandler handler) throws IOException, InvalidIniFormatException
     {
         class XmlToIni extends DefaultHandler
         {
             private static final String TAG_SECTION = "section";
             private static final String TAG_OPTION = "option";
             private static final String TAG_INI = "ini";
             private static final String ATTR_KEY = "key";
             private static final String ATTR_VALUE = "value";
             private static final String ATTR_VERSION = "version";
             private static final String CURRENT_VERSION = "1.0";
 
             @Override public void startElement(String uri, String localName, String qname, Attributes attrs) throws SAXException
             {
                 String key = attrs.getValue(ATTR_KEY);
 
                 if (qname.equals(TAG_INI))
                 {
                     String ver = attrs.getValue(ATTR_VERSION);
 
                     if ((ver == null) || !ver.equals(CURRENT_VERSION))
                     {
                         throw new SAXException("Missing or invalid 'version' attribute");
                     }
 
                     handler.startIni();
                 }
                 else
                 {
                     if (key == null)
                     {
                         throw new SAXException("missing '" + ATTR_KEY + "' attribute");
                     }
 
                     if (qname.equals(TAG_SECTION))
                     {
                         handler.startSection(key);
                     }
                     else if (qname.equals(TAG_OPTION))
                     {
                         handler.handleOption(key, attrs.getValue(ATTR_VALUE));
                     }
                     else
                     {
                         throw new SAXException("Invalid element: " + qname);
                     }
                 }
             }
 
             @Override public void endElement(String uri, String localName, String qname) throws SAXException
             {
                 if (qname.equals(TAG_SECTION))
                 {
                     handler.endSection();
                 }
                 else if (qname.equals(TAG_INI))
                 {
                     handler.endIni();
                 }
             }
         }
 
         XmlToIni xmlToini = new XmlToIni();
 
         try
         {
             SAXParserFactory.newInstance().newSAXParser().parse(new InputSource(input), xmlToini);
         }
         catch (Exception x)
         {
             throw new InvalidIniFormatException(x);
         }
     }
 
     public void parseXML(URL input, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         parseXML(input.openStream(), handler);
     }
 
     private String parseSectionLine(String line, IniSource source, IniHandler handler) throws InvalidIniFormatException
     {
         String sectionName;
 
         if (line.charAt(line.length() - 1) != SECTION_END)
         {
             parseError(line, source.getLineNumber());
         }
 
         sectionName = unescape(line.substring(1, line.length() - 1).trim());
         if ((sectionName.length() == 0) && !getConfig().isUnnamedSection())
         {
             parseError(line, source.getLineNumber());
         }
 
         if (getConfig().isLowerCaseSection())
         {
             sectionName = sectionName.toLowerCase(Locale.getDefault());
         }
 
         handler.startSection(sectionName);
 
         return sectionName;
     }
 
     private void parse(IniSource source, IniHandler handler) throws IOException, InvalidIniFormatException
     {
         handler.startIni();
         String sectionName = null;
 
         for (String line = source.readLine(); line != null; line = source.readLine())
         {
 
             if (line.charAt(0) == SECTION_BEGIN)
             {
                 if (sectionName != null)
                 {
                     handler.endSection();
                 }
 
                 sectionName = parseSectionLine(line, source, handler);
 
             }
             else
             {
                 if (sectionName == null)
                 {
                     if (getConfig().isGlobalSection())
                     {
                         sectionName = getConfig().getGlobalSectionName();
                         handler.startSection(sectionName);
                     }
                     else
                     {
                         parseError(line, source.getLineNumber());
                     }
                 }
 
                 parseOptionLine(line, handler, source.getLineNumber());
 
             }
         }
 
         if (sectionName != null)
         {
             handler.endSection();
         }
 
         handler.endIni();
     }
 }

1		/*
2		* Copyright 2005,2009 Ivan SZKIBA
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		package org.ini4j;
17
18		import org.ini4j.spi.ServiceFinder;
19
20		import org.xml.sax.Attributes;
21		import org.xml.sax.InputSource;
22		import org.xml.sax.SAXException;
23		import org.xml.sax.helpers.DefaultHandler;
24
25		import java.io.IOException;
26		import java.io.InputStream;
27		import java.io.InputStreamReader;
28		import java.io.Reader;
29
30		import java.net.URL;
31
32		import java.util.Locale;
33
34		import javax.xml.parsers.SAXParserFactory;
35
36		public class IniParser extends AbstractParser
37		{
38		private static final String COMMENTS = ";#";
39		private static final String OPERATORS = ":=";
40
41		public static final char SECTION_BEGIN = '[';
42		public static final char SECTION_END = ']';
43
44		public IniParser()
45		{
46	75	super(OPERATORS, COMMENTS);
47	75	}
48
49		public static IniParser newInstance()
50		{
51	69	return ServiceFinder.findService(IniParser.class);
52		}
53
54		public static IniParser newInstance(Config config)
55		{
56	66	IniParser instance = newInstance();
57
58	66	instance.setConfig(config);
59
60	66	return instance;
61		}
62
63		public void parse(InputStream input, IniHandler handler) throws IOException, InvalidIniFormatException
64		{
65	37	parse(newIniSource(input), handler);
66	24	}
67
68		public void parse(Reader input, IniHandler handler) throws IOException, InvalidIniFormatException
69		{
70	26	parse(newIniSource(input), handler);
71	24	}
72
73		public void parse(URL input, IniHandler handler) throws IOException, InvalidIniFormatException
74		{
75	17	parse(newIniSource(input), handler);
76	15	}
77
78		public void parseXML(InputStream input, IniHandler handler) throws IOException, InvalidIniFormatException
79		{
80	8	parseXML(new InputStreamReader(input), handler);
81	2	}
82
83		public void parseXML(Reader input, final IniHandler handler) throws IOException, InvalidIniFormatException
84		{
85	11	class XmlToIni extends DefaultHandler
86		{
87		private static final String TAG_SECTION = "section";
88		private static final String TAG_OPTION = "option";
89		private static final String TAG_INI = "ini";
90		private static final String ATTR_KEY = "key";
91		private static final String ATTR_VALUE = "value";
92		private static final String ATTR_VERSION = "version";
93		private static final String CURRENT_VERSION = "1.0";
94
95		@Override public void startElement(String uri, String localName, String qname, Attributes attrs) throws SAXException
96		{
97	249	String key = attrs.getValue(ATTR_KEY);
98
99	249	if (qname.equals(TAG_INI))
100		{
101	10	String ver = attrs.getValue(ATTR_VERSION);
102
103	10	if ((ver == null) \|\| !ver.equals(CURRENT_VERSION))
104		{
105	2	throw new SAXException("Missing or invalid 'version' attribute");
106		}
107
108	8	handler.startIni();
109	8	}
110		else
111		{
112	239	if (key == null)
113		{
114	2	throw new SAXException("missing '" + ATTR_KEY + "' attribute");
115		}
116
117	237	if (qname.equals(TAG_SECTION))
118		{
119	39	handler.startSection(key);
120		}
121	198	else if (qname.equals(TAG_OPTION))
122		{
123	197	handler.handleOption(key, attrs.getValue(ATTR_VALUE));
124		}
125		else
126		{
127	1	throw new SAXException("Invalid element: " + qname);
128		}
129		}
130	244	}
131
132		@Override public void endElement(String uri, String localName, String qname) throws SAXException
133		{
134	240	if (qname.equals(TAG_SECTION))
135		{
136	38	handler.endSection();
137		}
138	202	else if (qname.equals(TAG_INI))
139		{
140	5	handler.endIni();
141		}
142	240	}
143		}
144
145	11	XmlToIni xmlToini = new XmlToIni();
146
147		try
148		{
149	11	SAXParserFactory.newInstance().newSAXParser().parse(new InputSource(input), xmlToini);
150		}
151	6	catch (Exception x)
152		{
153	6	throw new InvalidIniFormatException(x);
154	5	}
155	5	}
156
157		public void parseXML(URL input, IniHandler handler) throws IOException, InvalidIniFormatException
158		{
159	1	parseXML(input.openStream(), handler);
160	1	}
161
162		private String parseSectionLine(String line, IniSource source, IniHandler handler) throws InvalidIniFormatException
163		{
164		String sectionName;
165
166	385	if (line.charAt(line.length() - 1) != SECTION_END)
167		{
168	6	parseError(line, source.getLineNumber());
169		}
170
171	379	sectionName = unescape(line.substring(1, line.length() - 1).trim());
172	379	if ((sectionName.length() == 0) && !getConfig().isUnnamedSection())
173		{
174	2	parseError(line, source.getLineNumber());
175		}
176
177	377	if (getConfig().isLowerCaseSection())
178		{
179	106	sectionName = sectionName.toLowerCase(Locale.getDefault());
180		}
181
182	377	handler.startSection(sectionName);
183
184	377	return sectionName;
185		}
186
187		private void parse(IniSource source, IniHandler handler) throws IOException, InvalidIniFormatException
188		{
189	79	handler.startIni();
190	79	String sectionName = null;
191
192	2243	for (String line = source.readLine(); line != null; line = source.readLine())
193		{
194
195	2179	if (line.charAt(0) == SECTION_BEGIN)
196		{
197	385	if (sectionName != null)
198		{
199	315	handler.endSection();
200		}
201
202	385	sectionName = parseSectionLine(line, source, handler);
203
204		}
205		else
206		{
207	1794	if (sectionName == null)
208		{
209	4	if (getConfig().isGlobalSection())
210		{
211	2	sectionName = getConfig().getGlobalSectionName();
212	2	handler.startSection(sectionName);
213		}
214		else
215		{
216	2	parseError(line, source.getLineNumber());
217		}
218		}
219
220	1792	parseOptionLine(line, handler, source.getLineNumber());
221
222		}
223		}
224
225	63	if (sectionName != null)
226		{
227	59	handler.endSection();
228		}
229
230	63	handler.endIni();
231	63	}
232		}