requiredChildren = this.requiredChilden;
196 | if (requiredChildren != null) {
197 | for (int i = requiredChildren.size() - 1; i >= 0; i--) {
198 | Element child = requiredChildren.get(i);
199 | if (!child.visited) {
200 | throw new BadXmlException(
201 | "Element named " + this + " is missing required"
202 | + " child element named "
203 | + child + ".", locator
204 | );
205 | }
206 | }
207 | }
208 | }
209 | }
210 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/ElementListener.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | /*
4 | * Copyright (C) 2007 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | /**
20 | * Listens for the beginning and ending of elements.
21 | */
22 | public interface ElementListener extends StartElementListener, EndElementListener {
23 | }
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/EndElementListener.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | /*
4 | * Copyright (C) 2007 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | /**
20 | * Listens for the end of elements.
21 | */
22 | public interface EndElementListener {
23 |
24 | /**
25 | * Invoked at the end of an element.
26 | */
27 | void end();
28 | }
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/EndTextElementListener.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | /*
4 | * Copyright (C) 2007 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | /**
20 | * Listens for the end of text elements.
21 | */
22 | public interface EndTextElementListener {
23 |
24 | /**
25 | * Invoked at the end of a text element with the body of the element.
26 | *
27 | * @param body of the element
28 | */
29 | void end(String body);
30 | }
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/RootElement.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | /*
4 | * Copyright (C) 2007 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import org.xml.sax.Attributes;
20 | import org.xml.sax.ContentHandler;
21 | import org.xml.sax.Locator;
22 | import org.xml.sax.SAXException;
23 | import org.xml.sax.helpers.DefaultHandler;
24 |
25 | /**
26 | * The root XML element. The entry point for this API. Not safe for concurrent
27 | * use.
28 | *
29 | * For example, passing this XML:
30 | *
31 | *
32 | * <feed xmlns='http://www.w3.org/2005/Atom'>
33 | * <entry>
34 | * <id>bob</id>
35 | * </entry>
36 | * </feed>
37 | *
38 | *
39 | * to this code:
40 | *
41 | *
42 | * static final String ATOM_NAMESPACE = "http://www.w3.org/2005/Atom";
43 | *
44 | * ...
45 | *
46 | * RootElement root = new RootElement(ATOM_NAMESPACE, "feed");
47 | * Element entry = root.getChild(ATOM_NAMESPACE, "entry");
48 | * entry.getChild(ATOM_NAMESPACE, "id").setEndTextElementListener(
49 | * new EndTextElementListener() {
50 | * public void end(String body) {
51 | * System.out.println("Entry ID: " + body);
52 | * }
53 | * });
54 | *
55 | * XMLReader reader = ...;
56 | * reader.setContentHandler(root.getContentHandler());
57 | * reader.parse(...);
58 | *
59 | *
60 | * would output:
61 | *
62 | *
63 | * Entry ID: bob
64 | *
65 | */
66 | public class RootElement extends Element {
67 |
68 | final Handler handler = new Handler();
69 |
70 | /**
71 | * Constructs a new root element with the given name.
72 | *
73 | * @param uri the namespace
74 | * @param localName the local name
75 | */
76 | public RootElement(String uri, String localName) {
77 | super(null, uri, localName, 0);
78 | }
79 |
80 | /**
81 | * Constructs a new root element with the given name. Uses an empty string
82 | * as the namespace.
83 | *
84 | * @param localName the local name
85 | */
86 | public RootElement(String localName) {
87 | this("", localName);
88 | }
89 |
90 | /**
91 | * Gets the SAX {@code ContentHandler}. Pass this to your SAX parser.
92 | */
93 | public ContentHandler getContentHandler() {
94 | return this.handler;
95 | }
96 |
97 | class Handler extends DefaultHandler {
98 |
99 | Locator locator;
100 | int depth = -1;
101 | Element current = null;
102 | StringBuilder bodyBuilder = null;
103 |
104 | @Override
105 | public void setDocumentLocator(Locator locator) {
106 | this.locator = locator;
107 | }
108 |
109 | @Override
110 | public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
111 | int depth = ++this.depth;
112 |
113 | if (depth == 0) {
114 | // This is the root element.
115 | startRoot(uri, localName, attributes);
116 | return;
117 | }
118 |
119 | // Prohibit mixed text and elements.
120 | if (bodyBuilder != null) {
121 | throw new BadXmlException(
122 | "Encountered mixed content"
123 | + " within text element named " + current + ".",
124 | locator
125 | );
126 | }
127 |
128 | // If we're one level below the current element.
129 | if (depth == current.depth + 1) {
130 | // Look for a child to push onto the stack.
131 | Children children = current.children;
132 | if (children != null) {
133 | Element child = children.get(uri, localName);
134 | if (child != null) {
135 | start(child, attributes);
136 | }
137 | }
138 | }
139 | }
140 |
141 | void startRoot(String uri, String localName, Attributes attributes) throws SAXException {
142 | Element root = RootElement.this;
143 | if (root.uri.compareTo(uri) != 0 || root.localName.compareTo(localName) != 0) {
144 | throw new BadXmlException(
145 | "Root element name does"
146 | + " not match. Expected: " + root + ", Got: "
147 | + Element.toString(uri, localName), locator
148 | );
149 | }
150 |
151 | start(root, attributes);
152 | }
153 |
154 | void start(Element e, Attributes attributes) {
155 | // Push element onto the stack.
156 | this.current = e;
157 |
158 | if (e.startElementListener != null) {
159 | e.startElementListener.start(attributes);
160 | }
161 |
162 | if (e.endTextElementListener != null) {
163 | this.bodyBuilder = new StringBuilder();
164 | }
165 |
166 | e.resetRequiredChildren();
167 | e.visited = true;
168 | }
169 |
170 | @Override
171 | public void characters(char[] buffer, int start, int length)
172 | throws SAXException {
173 | if (bodyBuilder != null) {
174 | bodyBuilder.append(buffer, start, length);
175 | }
176 | }
177 |
178 | @Override
179 | public void endElement(String uri, String localName, String qName)
180 | throws SAXException {
181 | Element current = this.current;
182 |
183 | // If we've ended the current element...
184 | if (depth == current.depth) {
185 | current.checkRequiredChildren(locator);
186 |
187 | // Invoke end element listener.
188 | if (current.endElementListener != null) {
189 | current.endElementListener.end();
190 | }
191 |
192 | // Invoke end text element listener.
193 | if (bodyBuilder != null) {
194 | String body = bodyBuilder.toString();
195 | bodyBuilder = null;
196 |
197 | // We can assume that this listener is present.
198 | current.endTextElementListener.end(body);
199 | }
200 |
201 | // Pop element off the stack.
202 | this.current = current.parent;
203 | }
204 |
205 | depth--;
206 | }
207 | }
208 | }
209 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/StartElementListener.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 | /*
3 | * Copyright (C) 2007 The Android Open Source Project
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | import org.xml.sax.Attributes;
19 |
20 | /**
21 | * Listens for the beginning of elements.
22 | */
23 | public interface StartElementListener {
24 |
25 | /**
26 | * Invoked at the beginning of an element.
27 | *
28 | * @param attributes from the element
29 | */
30 | void start(Attributes attributes);
31 | }
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sax/TextElementListener.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | /*
4 | * Copyright (C) 2007 The Android Open Source Project
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | /**
20 | * Listens for the beginning and ending of text elements.
21 | */
22 | public interface TextElementListener extends StartElementListener,
23 | EndTextElementListener {
24 | }
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/Instigator.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import com.novoda.sax.EndElementListener;
4 | import com.novoda.sax.RootElement;
5 |
6 | /**
7 | * {@link SimpleTagInstigator } is an example implementation
8 | */
9 | public interface Instigator extends EndElementListener {
10 | /**
11 | * @return The root tag of your XML file
12 | */
13 | RootTag getRootTag();
14 |
15 | /**
16 | * This is where you traverse the xml 'tree' by using
17 | * {@link com.novoda.sexp.finder.ElementFinder ElementFinder}
18 | * or {@link com.novoda.sexp.parser.Parser Parser}
19 | * objects to parse the XML.
23 | * {@link com.novoda.sexp.finder.ElementFinder ElementFinder}
24 | * {@link com.novoda.sexp.marshaller.AttributeMarshaller AttributeMarshaller}
25 | * {@link com.novoda.sexp.marshaller.BodyMarshaller BodyMarshaller}
26 | * {@link com.novoda.sexp.parser.Parser Parser}
27 | * {@link com.novoda.sexp.parser.ParseWatcher ParseWatcher}
28 | * {@link com.novoda.sexp.parser.ListParseWatcher ListParseWatcher}
29 | *
30 | *
31 | * @param rootElement the root element of your XML file
32 | */
33 | void create(RootElement rootElement);
34 |
35 | /**
36 | * Called when the corresponding closing root tag of your XML file is found
37 | */
38 | @Override
39 | void end();
40 | }
41 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/RootTag.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | public class RootTag {
4 |
5 | private static final String UNUSED_NAMESPACE = "";
6 |
7 | private final String tag;
8 | private final String namespace;
9 |
10 | public static RootTag create(String tag) {
11 | return create(tag, UNUSED_NAMESPACE);
12 | }
13 |
14 | public static RootTag create(String tag, String namespace) {
15 | return new RootTag(tag, namespace);
16 | }
17 |
18 | private RootTag(String tag, String namespace) {
19 | this.tag = tag;
20 | this.namespace = namespace;
21 | }
22 |
23 | public String getTag() {
24 | return tag;
25 | }
26 |
27 | public String getNamespace() {
28 | return namespace;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/SimpleEasyXmlParser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import com.novoda.sax.RootElement;
4 | import com.novoda.sexp.finder.ElementFinderFactory;
5 |
6 | import java.io.ByteArrayInputStream;
7 | import java.io.InputStream;
8 | import java.io.UnsupportedEncodingException;
9 | import java.util.concurrent.CountDownLatch;
10 |
11 | import org.xml.sax.XMLReader;
12 |
13 | public class SimpleEasyXmlParser {
14 |
15 | /**
16 | * @return an {@link ElementFinderFactory} this Factory is how you select which XML elements to parse as what java types
17 | * see it's javadoc for more
18 | */
19 | public static ElementFinderFactory getElementFinderFactory() {
20 | return new ElementFinderFactory();
21 | }
22 |
23 | /**
24 | * @param xml the xml to parse
25 | * @param encoding the encoding of your xml
26 | * @param instigator your fully created parser of the xml
27 | * @throws UnsupportedEncodingException if the encoding you passed isn't suppored
28 | */
29 | public static void parse(String xml, String encoding, Instigator instigator) throws UnsupportedEncodingException {
30 | parse(new ByteArrayInputStream(xml.getBytes(encoding)), instigator, getDefaultSEXPXMLReader());
31 | }
32 |
33 | /**
34 | * @param xml the xml to parse
35 | * @param instigator your fully created parser of the xml
36 | */
37 | public static void parse(String xml, Instigator instigator) {
38 | parse(new ByteArrayInputStream(xml.getBytes()), instigator, getDefaultSEXPXMLReader());
39 | }
40 |
41 | /**
42 | * @param xml the xml to parse
43 | * @param instigator your fully created parser of the xml
44 | */
45 | public static void parse(InputStream xml, Instigator instigator) {
46 | parse(xml, instigator, getDefaultSEXPXMLReader());
47 | }
48 |
49 | /**
50 | * @param xml the xml to parse
51 | * @param instigator your fully created parser of the xml
52 | * @param xmlReader is the interface that an XML parser's SAX2 driver must implement , using this? _bad ass_ alert
53 | */
54 | public static void parse(String xml, Instigator instigator, XMLReader xmlReader) {
55 | parse(new ByteArrayInputStream(xml.getBytes()), instigator, xmlReader);
56 | }
57 |
58 | /**
59 | * @param xml the xml to parse
60 | * @param instigator your fully created parser of the xml
61 | * @param xmlReader is the interface that an XML parser's SAX2 driver must implement , using this? _bad ass_ alert
62 | */
63 | public static void parse(InputStream xml, Instigator instigator, XMLReader xmlReader) {
64 | RootTag rootTag = instigator.getRootTag();
65 | RootElement rootElement = new RootElement(rootTag.getNamespace(), rootTag.getTag());
66 | rootElement.setEndElementListener(instigator);
67 | instigator.create(rootElement);
68 | xmlReader.setContentHandler(rootElement.getContentHandler());
69 | XmlParser xmlParser = new XmlParser();
70 | xmlParser.parse(xml, xmlReader);
71 | }
72 |
73 | /**
74 | * @param xml the xml to parse
75 | * @param encoding the encoding of your xml
76 | * @param streamer your fully created streamer of the xml
77 | * @param the expected type of your parsed XML
78 | * @return your parsed XML as an object
79 | * @throws UnsupportedEncodingException if the encoding you passed isn't suppored
80 | */
81 | public static T parse(String xml, String encoding, Streamer streamer) throws UnsupportedEncodingException {
82 | return parse(new ByteArrayInputStream(xml.getBytes(encoding)), streamer, getDefaultSEXPXMLReader());
83 | }
84 |
85 | /**
86 | * @param xml the xml to parse
87 | * @param streamer your fully created streamer of the xml
88 | * @param the expected type of your parsed XML
89 | * @return your parsed XML as an object
90 | */
91 | public static T parse(String xml, Streamer streamer) {
92 | return parse(new ByteArrayInputStream(xml.getBytes()), streamer, getDefaultSEXPXMLReader());
93 | }
94 |
95 | /**
96 | * @param xml the xml to parse
97 | * @param streamer your fully created streamer of the xml
98 | * @param the expected type of your parsed XML
99 | * @return your parsed XML as an object
100 | */
101 | public static T parse(InputStream xml, Streamer streamer) {
102 | return parse(xml, streamer, getDefaultSEXPXMLReader());
103 | }
104 |
105 | /**
106 | * @param xml the xml to parse
107 | * @param streamer your fully created streamer of the xml
108 | * @param xmlReader is the interface that an XML parser's SAX2 driver must implement , using this? _bad ass_ alert
109 | * @param the expected type of your parsed XML
110 | * @return your parsed XML as an object
111 | */
112 | public static T parse(String xml, Streamer streamer, XMLReader xmlReader) {
113 | return parse(new ByteArrayInputStream(xml.getBytes()), streamer, xmlReader);
114 | }
115 |
116 | /**
117 | * @param xml the xml to parse
118 | * @param streamer your fully created streamer of the xml
119 | * @param xmlReader is the interface that an XML parser's SAX2 driver must implement , using this? _bad ass_ alert
120 | * @param the expected type of your parsed XML
121 | * @return your parsed XML as an object
122 | */
123 | public static T parse(InputStream xml, final Streamer streamer, XMLReader xmlReader) {
124 | final CountDownLatch latch = new CountDownLatch(1);
125 | Instigator latchedInstigator = new Instigator() {
126 | @Override
127 | public RootTag getRootTag() {
128 | return streamer.getRootTag();
129 | }
130 |
131 | @Override
132 | public void create(RootElement rootElement) {
133 | streamer.stream(rootElement);
134 | }
135 |
136 | @Override
137 | public void end() {
138 | latch.countDown();
139 | }
140 | };
141 |
142 | RootTag rootTag = streamer.getRootTag();
143 | RootElement rootElement = new RootElement(rootTag.getNamespace(), rootTag.getTag());
144 | rootElement.setEndElementListener(latchedInstigator);
145 | streamer.stream(rootElement);
146 | xmlReader.setContentHandler(rootElement.getContentHandler());
147 | XmlParser xmlParser = new XmlParser();
148 | xmlParser.parse(xml, xmlReader);
149 |
150 | try {
151 | latch.await();
152 | } catch (InterruptedException e) {
153 | throw new RuntimeException(e);
154 | }
155 |
156 | return streamer.getStreamResult();
157 | }
158 |
159 | private static XMLReader getDefaultSEXPXMLReader() {
160 | try {
161 | return new XMLReaderBuilder().allowNamespaceProcessing(true).build();
162 | } catch (XMLReaderBuilder.XMLReaderCreationException e) {
163 | throw new RuntimeException(e);
164 | }
165 | }
166 |
167 | }
168 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/SimpleTagInstigator.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import com.novoda.sax.RootElement;
4 | import com.novoda.sexp.finder.ElementFinder;
5 | import com.novoda.sexp.parser.ParseFinishWatcher;
6 |
7 | public abstract class SimpleTagInstigator implements Instigator {
8 |
9 | private final ElementFinder elementFinder;
10 | private final String elementTag;
11 | private final ParseFinishWatcher parseFinishWatcher;
12 |
13 | public SimpleTagInstigator(ElementFinder elementFinder, String elementTag, ParseFinishWatcher parseFinishWatcher) {
14 | this.elementFinder = elementFinder;
15 | this.elementTag = elementTag;
16 | this.parseFinishWatcher = parseFinishWatcher;
17 | }
18 |
19 | @Override
20 | public void create(RootElement element) {
21 | elementFinder.find(element, elementTag);
22 | }
23 |
24 | @Override
25 | public void end() {
26 | parseFinishWatcher.onFinish();
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/Streamer.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import com.novoda.sax.RootElement;
4 |
5 | /**
6 | * This streamer can be used when you want to return your parsed object synchronously.
7 | * A good example being {@link SimpleEasyXmlParser#parse(String, Streamer)}
8 | *
9 | * @param the type of object you expect as a result of xml parsing
10 | */
11 | public interface Streamer {
12 | /**
13 | * @return The root tag of your XML file
14 | */
15 | RootTag getRootTag();
16 |
17 | /**
18 | * This is where you stream the xml 'tree' by using
19 | * {@link com.novoda.sexp.finder.ElementFinder ElementFinder}
20 | * or {@link com.novoda.sexp.parser.Parser Parser}
21 | * objects to parse the XML.
25 | * {@link com.novoda.sexp.finder.ElementFinder ElementFinder}
26 | * {@link com.novoda.sexp.marshaller.AttributeMarshaller AttributeMarshaller}
27 | * {@link com.novoda.sexp.marshaller.BodyMarshaller BodyMarshaller}
28 | * {@link com.novoda.sexp.parser.Parser Parser}
29 | * {@link com.novoda.sexp.parser.ParseWatcher ParseWatcher}
30 | * {@link com.novoda.sexp.parser.ListParseWatcher ListParseWatcher}
31 | *
32 | *
33 | * @param rootElement the root element of your XML file
34 | */
35 | void stream(RootElement rootElement);
36 |
37 | /**
38 | * @return the object you expected to be streamed
39 | */
40 | R getStreamResult();
41 | }
42 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/XMLReaderBuilder.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import javax.xml.parsers.ParserConfigurationException;
4 | import javax.xml.parsers.SAXParser;
5 | import javax.xml.parsers.SAXParserFactory;
6 | import javax.xml.validation.Schema;
7 |
8 | import org.xml.sax.SAXException;
9 | import org.xml.sax.SAXNotRecognizedException;
10 | import org.xml.sax.SAXNotSupportedException;
11 | import org.xml.sax.XMLReader;
12 |
13 | public class XMLReaderBuilder {
14 |
15 | private static final String FEATURE_NAMESPACE = "http://xml.org/sax/features/namespaces";
16 | private static final String FEATURE_NAMESPACE_PREFIX = "http://xml.org/sax/features/namespace-prefixes";
17 |
18 | private final SAXParserFactory saxParserFactory;
19 |
20 | public XMLReaderBuilder() {
21 | this(SAXParserFactory.newInstance());
22 | }
23 |
24 | XMLReaderBuilder(SAXParserFactory saxParserFactory) {
25 | this.saxParserFactory = saxParserFactory;
26 | }
27 |
28 | /**
29 | * Sets the particular feature in the underlying implementation of org.xml.sax.XMLReader. http://xerces.apache.org/xerces2-j/features.html
30 | *
31 | * @param name The name of the feature to be set.
32 | * @param value The value of the feature to be set.
33 | * @return XMLReaderBuilder
34 | * @throws XMLReaderCreationException
35 | */
36 |
37 | public XMLReaderBuilder withFeature(String name, boolean value) throws XMLReaderCreationException {
38 | try {
39 | saxParserFactory.setFeature(name, value);
40 | } catch (ParserConfigurationException e) {
41 | throw new XMLReaderCreationException(e);
42 | } catch (SAXNotRecognizedException e) {
43 | throw new XMLReaderCreationException(e);
44 | } catch (SAXNotSupportedException e) {
45 | throw new XMLReaderCreationException(e);
46 | }
47 | return this;
48 | }
49 |
50 | /**
51 | * Perform namespace processing: prefixes will be stripped off element and attribute names and
52 | * replaced with the corresponding namespace URIs. By default, the two will simply be concatenated,
53 | * but the namespace-sep core property allows the application to specify a delimiter string for
54 | * separating the URI part and the local part.
55 | *
56 | * @param allowProcessing enables/disables the processing
57 | * @return XMLReaderBuilder
58 | * @throws XMLReaderCreationException
59 | */
60 | public XMLReaderBuilder allowNamespaceProcessing(boolean allowProcessing) throws XMLReaderCreationException {
61 | withFeature(FEATURE_NAMESPACE, allowProcessing);
62 | return this;
63 | }
64 |
65 | /**
66 | * Report the original prefixed names and attributes used for namespace declarations.
67 | *
68 | * @param allowProcessing enables/disables the processing
69 | * @return XMLReaderBuilder
70 | * @throws XMLReaderCreationException
71 | */
72 | public XMLReaderBuilder allowAttributeNamespaceProcessing(boolean allowProcessing) throws XMLReaderCreationException {
73 | withFeature(FEATURE_NAMESPACE_PREFIX, allowProcessing);
74 | return this;
75 | }
76 |
77 | /**
78 | * Specifies that the parser produced by this code will provide support for XML namespaces.
79 | *
80 | * @param isAware enables/disables the processing
81 | * @return XMLReaderBuilder
82 | */
83 | public XMLReaderBuilder setNamespaceAware(boolean isAware) {
84 | saxParserFactory.setNamespaceAware(isAware);
85 | return this;
86 | }
87 |
88 | /**
89 | * Set state of XInclude processing.
90 | *
91 | * @param includeAware
92 | * @return XMLReaderBuilder
93 | */
94 | public XMLReaderBuilder setXIncludeAware(boolean includeAware) {
95 | saxParserFactory.setXIncludeAware(includeAware);
96 | return this;
97 | }
98 |
99 | /**
100 | * Set the {@link Schema} to be used by parsers created
101 | * from this factory
102 | *
103 | * @param schema
104 | * @return XMLReaderBuilder
105 | */
106 | public XMLReaderBuilder setSchema(Schema schema) {
107 | saxParserFactory.setSchema(schema);
108 | return this;
109 | }
110 |
111 | /**
112 | * Create the XMLReader with the specified options
113 | *
114 | * @return XMLReader
115 | * @throws XMLReaderCreationException
116 | */
117 | public XMLReader build() throws XMLReaderCreationException {
118 | try {
119 | SAXParser saxParser = saxParserFactory.newSAXParser();
120 | return saxParser.getXMLReader();
121 | } catch (ParserConfigurationException e) {
122 | throw new XMLReaderCreationException(e);
123 | } catch (SAXException e) {
124 | throw new XMLReaderCreationException(e);
125 | }
126 | }
127 |
128 | public static class XMLReaderCreationException extends Exception {
129 | public XMLReaderCreationException(Exception e) {
130 | super(e);
131 | }
132 | }
133 |
134 | }
135 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/XmlParser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import java.io.ByteArrayInputStream;
4 | import java.io.IOException;
5 | import java.io.InputStream;
6 |
7 | import org.xml.sax.InputSource;
8 | import org.xml.sax.SAXException;
9 | import org.xml.sax.XMLReader;
10 |
11 | public class XmlParser {
12 |
13 | public void parse(String xml, XMLReader xmlReader) {
14 | parse(new ByteArrayInputStream(xml.getBytes()), xmlReader);
15 | }
16 |
17 | public void parse(InputStream xml, XMLReader xmlReader) {
18 | try {
19 | InputSource input = new InputSource(xml);
20 | xmlReader.parse(input);
21 | } catch (IOException e) {
22 | throw new RuntimeException(e);
23 | } catch (SAXException e) {
24 | throw new RuntimeException(e);
25 | }
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/finder/BasicElementFinder.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sexp.parser.Parser;
5 |
6 | public class BasicElementFinder implements ElementFinder {
7 |
8 | private final Parser parser;
9 | private T result;
10 |
11 | public BasicElementFinder(Parser parser) {
12 | this.parser = parser;
13 | this.result = null;
14 | }
15 |
16 | @Override
17 | public void find(Element from, String tag) {
18 | parser.parse(from.getChild(tag), this);
19 | }
20 |
21 | @Override
22 | public void find(Element from, String uri, String tag) {
23 | parser.parse(from.getChild(uri, tag), this);
24 | }
25 |
26 | @Override
27 | public void onParsed(T body) {
28 | result = body;
29 | }
30 |
31 | @Override
32 | public T getResult() {
33 | return result;
34 | }
35 |
36 | @Override
37 | public T getResultOrThrow() {
38 | validateResult();
39 | return result;
40 | }
41 |
42 | @Override
43 | public T popResult() {
44 | try {
45 | return result;
46 | } finally {
47 | result = null;
48 | }
49 | }
50 |
51 | @Override
52 | public T popResultOrThrow() {
53 | validateResult();
54 | return popResult();
55 | }
56 |
57 | private void validateResult() {
58 | if (result == null) {
59 | throw new ResultNotFoundException();
60 | }
61 | }
62 |
63 | public static class ResultNotFoundException extends RuntimeException {
64 | public ResultNotFoundException() {
65 | super("Did you call find() with a valid tag and/or wait for the result to be parsed?");
66 | }
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/finder/ElementFinder.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sexp.parser.ParseWatcher;
5 |
6 | public interface ElementFinder extends ParseWatcher {
7 |
8 | /**
9 | * Find the given tag inside the given element
10 | *
11 | * @param from the XML element to search within
12 | * @param tag the XML tag to be searched for
13 | */
14 | void find(Element from, String tag);
15 |
16 | /**
17 | * Find the given tag inside the given element
18 | *
19 | * @param from the XML element to search within
20 | * @param uri the XML namespace of the searched for tag
21 | * @param tag the XML tag to be searched for
22 | */
23 | void find(Element from, String uri, String tag);
24 |
25 | @Override
26 | void onParsed(R item);
27 |
28 | /**
29 | * @return the result of the parsing if the parsing was completed and tag was found
30 | * or null if the tag was not found or parsing didn't complete.
31 | */
32 | R getResult();
33 |
34 | /**
35 | * @return the result of the parsing if the parsing was completed and tag was found
36 | * or throws an exception if the tag was not found or parsing didn't complete.
37 | */
38 | R getResultOrThrow();
39 |
40 | /**
41 | * Same as {@link #getResult} but clears the result instead of keeping it.
42 | * @return the result of the parsing if the parsing was completed and tag was found
43 | * or null if the tag was not found or parsing didn't complete.
44 | */
45 | R popResult();
46 |
47 | /**
48 | * Same as {@link #getResultOrThrow} but clears the result instead of keeping it.
49 | * @return the result of the parsing if the parsing was completed and tag was found
50 | * or throws an exception if the tag was not found or parsing didn't complete.
51 | */
52 | R popResultOrThrow();
53 | }
54 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/finder/ElementFinderFactory.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sexp.marshaller.AttributeMarshaller;
4 | import com.novoda.sexp.marshaller.BodyMarshaller;
5 | import com.novoda.sexp.marshaller.BooleanBodyMarshaller;
6 | import com.novoda.sexp.marshaller.IntegerBodyMarshaller;
7 | import com.novoda.sexp.marshaller.IntegerWrapperBodyMarshaller;
8 | import com.novoda.sexp.marshaller.StringBodyMarshaller;
9 | import com.novoda.sexp.marshaller.StringWrapperBodyMarshaller;
10 | import com.novoda.sexp.parser.BasicAttributeParser;
11 | import com.novoda.sexp.parser.BasicParser;
12 | import com.novoda.sexp.parser.ListParser;
13 | import com.novoda.sexp.parser.ParseWatcher;
14 | import com.novoda.sexp.parser.Parser;
15 |
16 | import java.util.List;
17 |
18 | /**
19 | * You can retrieve {@link ElementFinder ElementFinder's} here
20 | *
21 | * For example if you have the XML
22 | *
23 | * {@code Paul Blundell }
24 | *
25 | * and you want to retrieve it as a {@link String}
26 | * you would use the {@link #getStringFinder()} method
27 | *
28 | * {@code ElementFinder finder = getStringFinder();
29 | * finder.find(XML, "myTag");
30 | * String name = finder.getResultOrThrow();
31 | * }
32 | *
33 | */
34 | public class ElementFinderFactory {
35 |
36 | /**
37 | * Will parse the body of an XML tag into a {@link String}
38 | *
39 | * @return {@link ElementFinder}
40 | */
41 | public ElementFinder getStringFinder() {
42 | return getTypeFinder(new StringBodyMarshaller());
43 | }
44 |
45 | /**
46 | * Will parse the body of an XML tag into an {@link Integer}
47 | *
48 | * @return {@link ElementFinder}
49 | */
50 | public ElementFinder getIntegerFinder() {
51 | return getTypeFinder(new IntegerBodyMarshaller());
52 | }
53 |
54 | /**
55 | * Will parse the body of an XML tag into an {@link Boolean}
56 | *
57 | * @return {@link ElementFinder}
58 | */
59 | public ElementFinder getBooleanFinder() {
60 | return getTypeFinder(new BooleanBodyMarshaller());
61 | }
62 |
63 | /**
64 | * Will parse the body of an XML tag into a simple {@link Integer} wrapper class. This is a class that
65 | * has a constructor that takes a single primitive int parameter.
66 | *
67 | * @param clazz The class of your Integer Wrapper Class
68 | * @param The type you wish to create from the XML body
69 | * @return {@link ElementFinder}
70 | */
71 | public ElementFinder getIntegerWrapperTypeFinder(Class clazz) {
72 | return getTypeFinder(new BasicParser(getIntegerWrapperMarshaller(clazz)));
73 | }
74 |
75 | /**
76 | * Will parse the body of an XML tag into a simple {@link String} wrapper class. This is a class that
77 | * has a constructor that takes a single {@link String} parameter.
78 | *
79 | * @param clazz The class of your String Wrapper Class
80 | * @param The type you wish to create from the XML body
81 | * @return {@link ElementFinder}
82 | */
83 | public ElementFinder getStringWrapperTypeFinder(Class clazz) {
84 | return getTypeFinder(new BasicParser(getStringWrapperMarshaller(clazz)));
85 | }
86 |
87 | /**
88 | * Will parse the body of all XML tags with the {@code tag} argument
89 | * into a {@link java.util.List} of {@link Object} using the supplied {@link BodyMarshaller}.
90 | *
91 | * {@code
92 | * Paul
93 | * Peter
94 | *
95 | *
96 | * ElementFinder finder = getListFinder("name", marshallerOfT);
97 | * finder.find(element, "names");
98 | * List names = finder.getResultOrThrow();
99 | * }
100 | *
101 | *
102 | * @param tag The tag to parse the body for each list element
103 | * @param bodyMarshaller The marshaller to parse the body into your required type
104 | * @param The type you wish to create from the XML body
105 | * @return {@link ElementFinder}
106 | */
107 | public ElementFinder> getListFinder(String tag, BodyMarshaller bodyMarshaller) {
108 | return getTypeFinder(new ListParser(tag, this, bodyMarshaller));
109 | }
110 |
111 | /**
112 | * Will parse the body of all XML tags with the {@code tag} argument
113 | * into a {@link java.util.List} of {@link Object}. This is a simple String wrapper class that
114 | * has a constructor that takes a single {@link String} parameter. The type you wish to create from the XML body
120 | * @return {@link ElementFinder}
121 | */
122 | public ElementFinder> getStringWrapperTypeListFinder(String tag, Class clazz) {
123 | return getTypeFinder(new ListParser(tag, this, getStringWrapperMarshaller(clazz)));
124 | }
125 |
126 | /**
127 | * Will parse the body of all XML tags with the {@code tag} argument
128 | * into a {@link java.util.List} of {@link Object}. This is a simple Integer wrapper class that
129 | * has a constructor that takes a single {@link Integer} parameter. The type you wish to create from the XML body
135 | * @return {@link ElementFinder}
136 | */
137 | public ElementFinder> getIntegerWrapperTypeListFinder(String tag, Class clazz) {
138 | return getTypeFinder(new ListParser(tag, this, getIntegerWrapperMarshaller(clazz)));
139 | }
140 |
141 | /**
142 | * Will parse the attributes off an XML tag, these are then passed to your {@link AttributeMarshaller}
143 | * to create an object of type {@link Object}.
144 | *
145 | * @param attributeMarshaller The marshaller to parse the attributes into your required type
146 | * @param attrTags The tags of the attributes you wish to parse
147 | * @param The type you wish to create from the attributes
148 | * @return {@link ElementFinder}
149 | */
150 | public ElementFinder getAttributeFinder(AttributeMarshaller attributeMarshaller, String... attrTags) {
151 | return getTypeFinder(new BasicAttributeParser(attributeMarshaller, attrTags));
152 | }
153 |
154 | /**
155 | * Will parse the attributes off an XML tag, into {@link Object} then inform the {@link ParseWatcher}
156 | * The idea is to have a callback for a number of elements to create a {@link java.util.List}
157 | *
158 | * @param attributeMarshaller The marshaller to parse the attributes into your required type
159 | * @param watcher The watcher on elements to be informed of object creation
160 | * @param attrTags The tags of the attributes you wish to parse
161 | * @param The type you wish to create from the XML body
162 | * @return {@link ElementFinder}
163 | */
164 | public ElementFinder getListAttributeFinder(AttributeMarshaller attributeMarshaller, ParseWatcher watcher, String... attrTags) {
165 | return new ListElementFinder(new BasicAttributeParser(attributeMarshaller, attrTags), watcher);
166 | }
167 |
168 | /**
169 | * Will parse the body of an XML tag into {@link Object} using the supplied {@link BodyMarshaller}
170 | *
171 | * @param bodyMarshaller The marshaller to parse the body into your required type
172 | * @param The type you wish to create from the XML body
173 | * @return {@link ElementFinder}
174 | */
175 | public ElementFinder getTypeFinder(BodyMarshaller bodyMarshaller) {
176 | return getTypeFinder(new BasicParser(bodyMarshaller));
177 | }
178 |
179 | /**
180 | * Will parse an XML tag using the passed {@link Parser}
181 | * This can be used when you want to parse attributes as well as the body into your object
182 | *
183 | * @param parser The parser you wish to parse the XML with
184 | * @param The type you wish to create from the XML body
185 | * @return {@link ElementFinder}
186 | */
187 | public ElementFinder getTypeFinder(Parser parser) {
188 | return new BasicElementFinder(parser);
189 | }
190 |
191 | /**
192 | * Will parse the body of an XML tag into {@link Object} then inform the {@link ParseWatcher}
193 | * The idea is to have a callback for a number of elements to create a {@link java.util.List}
194 | *
195 | * @param bodyMarshaller The marshaller to create an object from the XML body
196 | * @param watcher The watcher on elements to be informed of object creation
197 | * @param The type you wish to create from the XML body
198 | * @return {@link ElementFinder}
199 | */
200 | public ElementFinder getListElementFinder(BodyMarshaller bodyMarshaller, ParseWatcher watcher) {
201 | return getListElementFinder(new BasicParser(bodyMarshaller), watcher);
202 | }
203 |
204 | /**
205 | * Will parse an XML tag into {@link Object} then inform the {@link ParseWatcher}
206 | * The idea is to have a callback for a number of elements to create a {@link java.util.List}
207 | * This can be used when you want to parse attributes as well as the XML body into your object
208 | *
209 | * @param parser The parser you wish to parse the XML with
210 | * @param watcher The watcher on elements to be informed of object creation
211 | * @param The type you wish to create from the XML body
212 | * @return {@link ElementFinder}
213 | */
214 | public ElementFinder getListElementFinder(Parser parser, ParseWatcher watcher) {
215 | return new ListElementFinder(parser, watcher);
216 | }
217 |
218 | private BodyMarshaller getStringWrapperMarshaller(Class clazz) {
219 | return new StringWrapperBodyMarshaller(clazz);
220 | }
221 |
222 | private BodyMarshaller getIntegerWrapperMarshaller(Class clazz) {
223 | return new IntegerWrapperBodyMarshaller(clazz);
224 | }
225 | }
226 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/finder/ListElementFinder.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sexp.parser.ParseWatcher;
5 | import com.novoda.sexp.parser.Parser;
6 |
7 | public class ListElementFinder implements ElementFinder {
8 |
9 | private final Parser parser;
10 | private final ParseWatcher parseWatcher;
11 |
12 | public ListElementFinder(Parser parser, ParseWatcher parseWatcher) {
13 | this.parser = parser;
14 | this.parseWatcher = parseWatcher;
15 | }
16 |
17 | @Override
18 | public void find(Element from, String tag) {
19 | parser.parse(from.getChild(tag), this);
20 | }
21 |
22 | @Override
23 | public void find(Element from, String uri, String tag) {
24 | parser.parse(from.getChild(uri, tag), this);
25 | }
26 |
27 | @Override
28 | public void onParsed(T body) {
29 | parseWatcher.onParsed(body);
30 | }
31 |
32 | @Override
33 | public T getResult() {
34 | throw new UnsupportedOperationException("Has a listener to pass each item as parsed, so there is no result.");
35 | }
36 |
37 | @Override
38 | public T getResultOrThrow() {
39 | throw new UnsupportedOperationException("Has a listener to pass each item as parsed, so there is no result.");
40 | }
41 |
42 | @Override
43 | public T popResult() {
44 | throw new UnsupportedOperationException("Has a listener to pass each item as parsed, so there is no result.");
45 | }
46 |
47 | @Override
48 | public T popResultOrThrow() {
49 | throw new UnsupportedOperationException("Has a listener to pass each item as parsed, so there is no result.");
50 | }
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/AttributeMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public interface AttributeMarshaller {
4 | T marshal(String... input);
5 | }
6 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/BodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public interface BodyMarshaller {
4 | T marshal(String input);
5 | }
6 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/BooleanBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public class BooleanBodyMarshaller implements BodyMarshaller {
4 | @Override
5 | public Boolean marshal(String input) {
6 | if ("true".equalsIgnoreCase(input)) {
7 | return true;
8 | } else if ("false".equalsIgnoreCase(input)) {
9 | return false;
10 | }
11 | throw new IllegalArgumentException("The input '" + input + "' is not a valid boolean (possible values are 'true' and 'false').");
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/DoubleBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public class DoubleBodyMarshaller implements BodyMarshaller {
4 | @Override
5 | public Double marshal(String input) {
6 | return Double.valueOf(input);
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/DoubleWrapperBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import java.lang.reflect.InvocationTargetException;
4 |
5 | public class DoubleWrapperBodyMarshaller implements BodyMarshaller {
6 |
7 | private final Class clazz;
8 |
9 | public DoubleWrapperBodyMarshaller(Class clazz) {
10 | this.clazz = clazz;
11 | }
12 |
13 | @Override
14 | public T marshal(String input) {
15 | try {
16 | return clazz.getDeclaredConstructor(double.class).newInstance(Double.parseDouble(input));
17 | } catch (InstantiationException e) {
18 | throw new RuntimeException(e);
19 | } catch (IllegalAccessException e) {
20 | throw new RuntimeException(e);
21 | } catch (InvocationTargetException e) {
22 | throw new RuntimeException(e);
23 | } catch (NoSuchMethodException e) {
24 | throw new RuntimeException(e);
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/IntegerBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public class IntegerBodyMarshaller implements BodyMarshaller {
4 | @Override
5 | public Integer marshal(String input) {
6 | return Integer.valueOf(input);
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/IntegerWrapperBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import java.lang.reflect.InvocationTargetException;
4 |
5 | public class IntegerWrapperBodyMarshaller implements BodyMarshaller {
6 |
7 | private final Class clazz;
8 |
9 | public IntegerWrapperBodyMarshaller(Class clazz) {
10 | this.clazz = clazz;
11 | }
12 |
13 | @Override
14 | public T marshal(String input) {
15 | try {
16 | return clazz.getDeclaredConstructor(int.class).newInstance(Integer.parseInt(input));
17 | } catch (InstantiationException e) {
18 | throw new RuntimeException(e);
19 | } catch (IllegalAccessException e) {
20 | throw new RuntimeException(e);
21 | } catch (InvocationTargetException e) {
22 | throw new RuntimeException(e);
23 | } catch (NoSuchMethodException e) {
24 | throw new RuntimeException(e);
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/LongBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public class LongBodyMarshaller implements BodyMarshaller {
4 | @Override
5 | public Long marshal(String input) {
6 | return Long.valueOf(input);
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/LongWrapperBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import java.lang.reflect.InvocationTargetException;
4 |
5 | public class LongWrapperBodyMarshaller implements BodyMarshaller {
6 |
7 | private final Class clazz;
8 |
9 | public LongWrapperBodyMarshaller(Class clazz) {
10 | this.clazz = clazz;
11 | }
12 |
13 | @Override
14 | public T marshal(String input) {
15 | try {
16 | return clazz.getDeclaredConstructor(long.class).newInstance(Long.parseLong(input));
17 | } catch (InstantiationException e) {
18 | throw new RuntimeException(e);
19 | } catch (IllegalAccessException e) {
20 | throw new RuntimeException(e);
21 | } catch (InvocationTargetException e) {
22 | throw new RuntimeException(e);
23 | } catch (NoSuchMethodException e) {
24 | throw new RuntimeException(e);
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/StringBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | public class StringBodyMarshaller implements BodyMarshaller {
4 |
5 | @Override
6 | public String marshal(String input) {
7 | return input;
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/marshaller/StringWrapperBodyMarshaller.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import java.lang.reflect.InvocationTargetException;
4 |
5 | public class StringWrapperBodyMarshaller implements BodyMarshaller {
6 |
7 | private final Class clazz;
8 |
9 | public StringWrapperBodyMarshaller(Class clazz) {
10 | this.clazz = clazz;
11 | }
12 |
13 | @Override
14 | public T marshal(String input) {
15 | try {
16 | return clazz.getDeclaredConstructor(String.class).newInstance(input);
17 | } catch (InstantiationException e) {
18 | throw new RuntimeException(e);
19 | } catch (IllegalAccessException e) {
20 | throw new RuntimeException(e);
21 | } catch (InvocationTargetException e) {
22 | throw new RuntimeException(e);
23 | } catch (NoSuchMethodException e) {
24 | throw new RuntimeException(e);
25 | }
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/BasicAttributeParser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sax.StartElementListener;
5 | import com.novoda.sexp.marshaller.AttributeMarshaller;
6 |
7 | import org.xml.sax.Attributes;
8 |
9 | public class BasicAttributeParser implements Parser, StartElementListener {
10 |
11 | private final AttributeMarshaller attributeMarshaller;
12 | private final String[] attrs;
13 | private ParseWatcher listener;
14 |
15 | public BasicAttributeParser(AttributeMarshaller attributeMarshaller, String... attrs) {
16 | this.attributeMarshaller = attributeMarshaller;
17 | this.attrs = attrs;
18 | }
19 |
20 | @Override
21 | public void parse(Element element, final ParseWatcher listener) {
22 | this.listener = listener;
23 | element.setStartElementListener(this);
24 | }
25 |
26 | @Override
27 | public void start(Attributes attributes) {
28 | String[] values = getAttributeValues(attributes);
29 | listener.onParsed(attributeMarshaller.marshal(values));
30 | }
31 |
32 | private String[] getAttributeValues(Attributes attributes) {
33 | String[] values = new String[attrs.length];
34 | for (int i = 0; i < attrs.length; i++) {
35 | values[i] = attributes.getValue(attrs[i]);
36 | }
37 | return values;
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/BasicParser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sax.EndTextElementListener;
5 | import com.novoda.sexp.marshaller.BodyMarshaller;
6 |
7 | public class BasicParser implements Parser {
8 |
9 | private final BodyMarshaller bodyMarshaller;
10 |
11 | public BasicParser(BodyMarshaller bodyMarshaller) {
12 | this.bodyMarshaller = bodyMarshaller;
13 | }
14 |
15 | @Override
16 | public void parse(Element element, final ParseWatcher listener) {
17 | element.setEndTextElementListener(
18 | new EndTextElementListener() {
19 | @Override
20 | public void end(String body) {
21 | listener.onParsed(bodyMarshaller.marshal(body));
22 | }
23 | }
24 | );
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/ListParseWatcher.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.ElementListener;
4 |
5 | import org.xml.sax.Attributes;
6 |
7 | public interface ListParseWatcher extends ParseWatcher, ElementListener {
8 | @Override
9 | void start(Attributes attributes);
10 |
11 | @Override
12 | void onParsed(T item);
13 |
14 | @Override
15 | void end();
16 | }
17 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/ListParser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sexp.finder.ElementFinder;
5 | import com.novoda.sexp.finder.ElementFinderFactory;
6 | import com.novoda.sexp.marshaller.BodyMarshaller;
7 |
8 | import java.util.ArrayList;
9 | import java.util.List;
10 |
11 | import org.xml.sax.Attributes;
12 |
13 | public class ListParser implements Parser>, ListParseWatcher {
14 |
15 | private final String tag;
16 | private final ElementFinder listCreator;
17 |
18 | private ParseWatcher> listener;
19 | private List list;
20 |
21 | public ListParser(String tag, ElementFinderFactory factory, BodyMarshaller bodyMarshaller) {
22 | this.tag = tag;
23 | this.listCreator = factory.getListElementFinder(bodyMarshaller, this);
24 | }
25 |
26 | @Override
27 | public void parse(Element element, ParseWatcher> listener) {
28 | this.listener = listener;
29 | element.setElementListener(this);
30 | listCreator.find(element, tag);
31 | }
32 |
33 | @Override
34 | public void start(Attributes attributes) {
35 | list = new ArrayList();
36 | }
37 |
38 | @Override
39 | public void onParsed(T item) {
40 | list.add(item);
41 | }
42 |
43 | @Override
44 | public void end() {
45 | listener.onParsed(list);
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/ParseFinishWatcher.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | public interface ParseFinishWatcher {
4 | void onFinish();
5 | }
6 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/ParseWatcher.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | public interface ParseWatcher {
4 | void onParsed(T item);
5 | }
6 |
--------------------------------------------------------------------------------
/sexp/src/main/java/com/novoda/sexp/parser/Parser.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.Element;
4 |
5 | public interface Parser {
6 | void parse(Element element, ParseWatcher listener);
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sax/ChildrenShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sax;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class ChildrenShould {
9 |
10 | private static final String FIRST_STRING_WITH_EQUAL_HASH = "0-42L";
11 | private static final String SECOND_STRING_WITH_EQUAL_HASH = "0-43-";
12 |
13 | private Children children;
14 | private Element parent;
15 |
16 | @Before
17 | public void setUp() {
18 | children = new Children();
19 | parent = new Element(null, "", "test", 0);
20 | }
21 |
22 | @Test
23 | public void create_new_child_with_equal_hash_uri_and_local() throws Exception {
24 | Element element = children.getOrCreate(parent, FIRST_STRING_WITH_EQUAL_HASH, FIRST_STRING_WITH_EQUAL_HASH);
25 | Element anotherElement = children.getOrCreate(parent, SECOND_STRING_WITH_EQUAL_HASH, SECOND_STRING_WITH_EQUAL_HASH);
26 |
27 | assertThat(element).isNotSameAs(anotherElement);
28 | }
29 |
30 | @Test
31 | public void same_child_with_equal_uri_and_local() {
32 | Element element = children.getOrCreate(parent, FIRST_STRING_WITH_EQUAL_HASH, FIRST_STRING_WITH_EQUAL_HASH);
33 | Element anotherElement = children.getOrCreate(parent, FIRST_STRING_WITH_EQUAL_HASH, FIRST_STRING_WITH_EQUAL_HASH);
34 |
35 | assertThat(element).isSameAs(anotherElement);
36 | }
37 |
38 | @Test
39 | public void return_proper_child_with_equal_hash_uri_and_local() {
40 | children.getOrCreate(parent, FIRST_STRING_WITH_EQUAL_HASH, FIRST_STRING_WITH_EQUAL_HASH);
41 |
42 | Element anotherElement = children.getOrCreate(parent, SECOND_STRING_WITH_EQUAL_HASH, SECOND_STRING_WITH_EQUAL_HASH);
43 |
44 | assertThat(children.get(SECOND_STRING_WITH_EQUAL_HASH, SECOND_STRING_WITH_EQUAL_HASH)).isSameAs(anotherElement);
45 | }
46 |
47 | }
48 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/RootTagShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.fest.assertions.api.Assertions.assertThat;
6 |
7 | public class RootTagShould {
8 |
9 | private static final String ROOT = "root";
10 | private static final String NAMESPACE = "namespace";
11 |
12 | @Test
13 | public void setRoot_onCreate() throws Exception {
14 | RootTag rootTag = RootTag.create(ROOT, NAMESPACE);
15 |
16 | assertThat(rootTag.getTag()).isEqualTo(ROOT);
17 | }
18 |
19 | @Test
20 | public void setNamespace_onCreate() throws Exception {
21 | RootTag rootTag = RootTag.create(ROOT, NAMESPACE);
22 |
23 | assertThat(rootTag.getNamespace()).isEqualTo(NAMESPACE);
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/XmlParserShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 | import org.mockito.Mock;
6 | import org.mockito.Mockito;
7 | import org.xml.sax.InputSource;
8 | import org.xml.sax.XMLReader;
9 |
10 | import static org.mockito.Mockito.verify;
11 | import static org.mockito.MockitoAnnotations.initMocks;
12 |
13 | public class XmlParserShould {
14 |
15 | @Mock
16 | XMLReader xmlReader;
17 |
18 | //language=XML
19 | private static final String xml =
20 | "" +
21 | "Blue " +
22 | " ";
23 |
24 | @Before
25 | public void setUp() throws Exception {
26 | initMocks(this);
27 | }
28 |
29 | @Test
30 | public void call_reader_parse_when_parse_is_called() throws Exception {
31 | XmlParser xmlParser = new XmlParser();
32 |
33 | xmlParser.parse(xml, xmlReader);
34 |
35 | verify(xmlReader).parse(Mockito.any());
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/finder/BasicElementFinderShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sexp.parser.Parser;
4 |
5 | import org.junit.Before;
6 | import org.junit.Test;
7 | import org.mockito.Mock;
8 |
9 | import static org.fest.assertions.api.Assertions.assertThat;
10 | import static org.mockito.Mockito.stub;
11 | import static org.mockito.Mockito.verify;
12 | import static org.mockito.MockitoAnnotations.initMocks;
13 |
14 | public class BasicElementFinderShould {
15 |
16 | @Mock
17 | private Parser mockParser;
18 | @Mock
19 | private com.novoda.sax.Element mockElement;
20 |
21 | BasicElementFinder elementCreator;
22 |
23 | @Before
24 | public void setUp() throws Exception {
25 | initMocks(this);
26 | elementCreator = new BasicElementFinder(mockParser);
27 | }
28 |
29 | @Test
30 | public void callParser_whenCreated() {
31 | String tag = "tag";
32 | stub(mockElement.getChild(tag)).toReturn(mockElement);
33 |
34 | elementCreator.find(mockElement, tag);
35 |
36 | verify(mockParser).parse(mockElement, elementCreator);
37 | }
38 |
39 | @Test
40 | public void get_child_elements_using_namspace_when_a_namespace_is_provided() throws Exception {
41 | String tag = "tag";
42 | String namespace = "namespace";
43 |
44 | elementCreator.find(mockElement, namespace, tag);
45 |
46 | verify(mockElement).getChild(namespace, tag);
47 | }
48 |
49 | @Test
50 | public void create_a_result_when_parsing_finished() throws Exception {
51 | String result = "result";
52 |
53 | elementCreator.onParsed(result);
54 |
55 | assertThat(elementCreator.getResult()).isEqualTo(result);
56 | }
57 |
58 | @Test(expected = BasicElementFinder.ResultNotFoundException.class)
59 | public void throw_exception_when_result_has_not_been_parsed_or_found_and_a_required_result_is_asked_for() throws Exception {
60 | elementCreator.getResultOrThrow();
61 | }
62 |
63 | @Test
64 | public void allow_null_results_when_get_result_is_used() throws Exception {
65 | Object result = elementCreator.getResult();
66 |
67 | assertThat(result).isNull();
68 | }
69 |
70 | @Test
71 | public void pop_a_result_when_parsing_finished() throws Exception {
72 | String result = "result";
73 | elementCreator.onParsed(result);
74 |
75 | Object actual = elementCreator.popResult();
76 |
77 | assertThat(actual).isEqualTo(result);
78 | }
79 |
80 | @Test(expected = BasicElementFinder.ResultNotFoundException.class)
81 | public void throw_exception_when_result_has_not_been_parsed_or_found_and_a_result_is_popped() throws Exception {
82 | elementCreator.popResultOrThrow();
83 | }
84 |
85 | @Test
86 | public void allow_null_results_when_get_result_is_popped() throws Exception {
87 | Object result = elementCreator.popResult();
88 |
89 | assertThat(result).isNull();
90 | }
91 |
92 | @Test
93 | public void not_cache_result_after_a_result_is_popped() throws Exception {
94 | elementCreator.onParsed("ignore");
95 | elementCreator.popResult();
96 |
97 | Object actual = elementCreator.popResult();
98 |
99 | assertThat(actual).isNull();
100 | }
101 |
102 | }
103 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/finder/ListElementFinderShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.finder;
2 |
3 | import com.novoda.sexp.parser.ParseWatcher;
4 | import com.novoda.sexp.parser.Parser;
5 |
6 | import org.junit.Before;
7 | import org.junit.Test;
8 | import org.mockito.Mock;
9 |
10 | import static org.mockito.Mockito.stub;
11 | import static org.mockito.Mockito.verify;
12 | import static org.mockito.MockitoAnnotations.initMocks;
13 |
14 | public class ListElementFinderShould {
15 |
16 | @Mock
17 | private Parser mockParser;
18 | @Mock
19 | private ParseWatcher mockWatcher;
20 |
21 | @Mock
22 | private com.novoda.sax.Element mockElement;
23 | ListElementFinder elementCreator;
24 |
25 | @Before
26 | public void setUp() throws Exception {
27 | initMocks(this);
28 | elementCreator = new ListElementFinder(mockParser, mockWatcher);
29 | }
30 |
31 | @Test
32 | public void callParser_whenCreated() {
33 | String tag = "tag";
34 | stub(mockElement.getChild(tag)).toReturn(mockElement);
35 |
36 | elementCreator.find(mockElement, tag);
37 |
38 | verify(mockParser).parse(mockElement, elementCreator);
39 | }
40 |
41 | @Test
42 | public void callWatcher_afterEachItemForTheListIsParsed() throws Exception {
43 | String result = "result";
44 |
45 | elementCreator.onParsed(result);
46 |
47 | verify(mockWatcher).onParsed(result);
48 | }
49 |
50 | @Test(expected = UnsupportedOperationException.class)
51 | public void notSupportGetResult_asListCreatorWillCallbackAfterEveryListItemIsParsed() throws Exception {
52 | elementCreator.getResult();
53 | }
54 |
55 | @Test(expected = UnsupportedOperationException.class)
56 | public void notSupportGetResultOrThrow_asListCreatorWillCallbackAfterEveryListItemIsParsed() throws Exception {
57 | elementCreator.getResultOrThrow();
58 | }
59 |
60 | @Test(expected = UnsupportedOperationException.class)
61 | public void notSupportPopResult_asListCreatorWillCallbackAfterEveryListItemIsParsed() throws Exception {
62 | elementCreator.popResult();
63 | }
64 |
65 | @Test(expected = UnsupportedOperationException.class)
66 | public void notSupportPopResultOrThrow_asListCreatorWillCallbackAfterEveryListItemIsParsed() throws Exception {
67 | elementCreator.popResultOrThrow();
68 | }
69 |
70 | }
71 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/BooleanBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class BooleanBodyMarshallerShould {
9 |
10 | private BooleanBodyMarshaller booleanBodyMarshaller;
11 |
12 | @Before
13 | public void setUp() throws Exception {
14 | booleanBodyMarshaller = new BooleanBodyMarshaller();
15 | }
16 |
17 | @Test
18 | public void marshal_string_false_to_boolean_false() throws Exception {
19 | String rawFalse = "false";
20 |
21 | assertThat(booleanBodyMarshaller.marshal(rawFalse)).isFalse();
22 | }
23 |
24 | @Test
25 | public void marshal_string_true_to_boolean_true() throws Exception {
26 | String rawTrue = "true";
27 |
28 | assertThat(booleanBodyMarshaller.marshal(rawTrue)).isTrue();
29 | }
30 |
31 | @Test(expected = IllegalArgumentException.class)
32 | public void throw_exception_when_input_is_invalid() throws Exception {
33 | String invalidInput = "invalid";
34 |
35 | booleanBodyMarshaller.marshal(invalidInput);
36 | }
37 |
38 | @Test(expected = IllegalArgumentException.class)
39 | public void throw_exception_when_input_is_null() throws Exception {
40 | booleanBodyMarshaller.marshal(null);
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/DoubleBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class DoubleBodyMarshallerShould {
9 |
10 | private DoubleBodyMarshaller doubleBodyMarshaller;
11 |
12 | @Before
13 | public void setUp() throws Exception {
14 | doubleBodyMarshaller = new DoubleBodyMarshaller();
15 | }
16 |
17 | @Test
18 | public void marshal_integer_strings_to_long() throws Exception {
19 | String validInput = "5";
20 | double expectedOutput = 5;
21 |
22 | assertThat(doubleBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
23 | }
24 |
25 | @Test
26 | public void marshal_long_strings_to_long() throws Exception {
27 | String validInput = String.valueOf(Long.MAX_VALUE);
28 | double expectedOutput = Long.MAX_VALUE;
29 |
30 | assertThat(doubleBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
31 | }
32 |
33 | @Test
34 | public void marshal_float_strings_to_long() throws Exception {
35 | String invalidInput = "0.5f";
36 | double expectedOutput = 0.5d;
37 |
38 | assertThat(doubleBodyMarshaller.marshal(invalidInput)).isEqualTo(expectedOutput);
39 | }
40 |
41 | @Test
42 | public void marshal_double_strings_to_long() throws Exception {
43 | String validInput = "120.234d";
44 | double expectedOutput = 120.234d;
45 |
46 | assertThat(doubleBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
47 | assertThat(doubleBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
48 | }
49 |
50 | @Test(expected = IllegalArgumentException.class)
51 | public void throw_exception_when_input_is_invalid() throws Exception {
52 | String invalidInput = "invalid";
53 |
54 | doubleBodyMarshaller.marshal(invalidInput);
55 | }
56 |
57 | @Test(expected = NullPointerException.class)
58 | public void throw_exception_when_input_is_null() throws Exception {
59 | doubleBodyMarshaller.marshal(null);
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/DoubleWrapperBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.fest.assertions.api.Assertions.assertThat;
6 |
7 | public class DoubleWrapperBodyMarshallerShould {
8 |
9 | @Test
10 | public void marshalStringInput() throws Exception {
11 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(DoubleWrapperClass.class);
12 |
13 | DoubleWrapperClass output = cut.marshal("42.42d");
14 |
15 | assertThat(output).isEqualTo(new DoubleWrapperClass(42.42d));
16 | }
17 |
18 | @Test(expected = RuntimeException.class)
19 | public void onlyWorkForClassesWithADoubleConstructorArgString() throws Exception {
20 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(StringWrapperClass.class);
21 |
22 | cut.marshal("");
23 | }
24 |
25 | @Test(expected = RuntimeException.class)
26 | public void onlyWorkForClassesWithADoubleConstructorArgInteger() throws Exception {
27 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(IntegerWrapperClass.class);
28 |
29 | cut.marshal("");
30 | }
31 |
32 | @Test(expected = RuntimeException.class)
33 | public void onlyWorkForClassesWithADoubleConstructorArgLong() throws Exception {
34 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(LongWrapperClass.class);
35 |
36 | cut.marshal("");
37 | }
38 |
39 | @Test(expected = RuntimeException.class)
40 | public void onlyWorkForClassesWithADoubleConstructorArgFloat() throws Exception {
41 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(FloatWrapperClass.class);
42 |
43 | cut.marshal("");
44 | }
45 |
46 |
47 | @Test(expected = RuntimeException.class)
48 | public void onlyWorkForClassesWithASingleConstructorArg() throws Exception {
49 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(TwoArgWrapperClass.class);
50 |
51 | cut.marshal("");
52 | }
53 |
54 | @Test(expected = RuntimeException.class)
55 | public void failForClassesWithNoArgConstructor() throws Exception {
56 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(NoArgWrapperClass.class);
57 |
58 | cut.marshal("");
59 | }
60 |
61 | @Test(expected = RuntimeException.class)
62 | public void failForClassesWithPrivateConstructor() throws Exception {
63 | DoubleWrapperBodyMarshaller cut = doubleWrapperBodyMarshaller(
64 | PrivateConstructorWrapperClass.class
65 | );
66 |
67 | cut.marshal("1");
68 | }
69 |
70 | private DoubleWrapperBodyMarshaller doubleWrapperBodyMarshaller(Class clazz) {
71 | return new DoubleWrapperBodyMarshaller(clazz);
72 | }
73 |
74 | private static class DoubleWrapperClass {
75 | private final double toWrap;
76 |
77 | public DoubleWrapperClass(double toWrap) {
78 | this.toWrap = toWrap;
79 | }
80 |
81 | @Override
82 | public boolean equals(Object o) {
83 | if (this == o) return true;
84 | if (o == null || getClass() != o.getClass()) return false;
85 |
86 | DoubleWrapperClass that = (DoubleWrapperClass) o;
87 |
88 | return Double.compare(that.toWrap, toWrap) == 0;
89 |
90 | }
91 |
92 | @Override
93 | public int hashCode() {
94 | long temp = Double.doubleToLongBits(toWrap);
95 | return (int) (temp ^ (temp >>> 32));
96 | }
97 | }
98 |
99 | private static class IntegerWrapperClass {
100 | private IntegerWrapperClass(int one) {
101 | }
102 | }
103 |
104 | private static class LongWrapperClass {
105 | private LongWrapperClass(long one) {
106 | }
107 | }
108 |
109 | private static class FloatWrapperClass {
110 | private FloatWrapperClass(float one) {
111 | }
112 | }
113 |
114 | private static class StringWrapperClass {
115 | private StringWrapperClass(String one) {
116 | }
117 | }
118 |
119 | private static class TwoArgWrapperClass {
120 | private TwoArgWrapperClass(double one, double two) {
121 | }
122 | }
123 |
124 | private static class NoArgWrapperClass {
125 | public NoArgWrapperClass() {
126 | }
127 | }
128 |
129 | private static class PrivateConstructorWrapperClass {
130 | private PrivateConstructorWrapperClass(double toWrap) {
131 | }
132 | }
133 |
134 | }
135 |
136 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/IntegerBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class IntegerBodyMarshallerShould {
9 |
10 | private IntegerBodyMarshaller integerBodyMarshaller;
11 |
12 | @Before
13 | public void setUp() throws Exception {
14 | integerBodyMarshaller = new IntegerBodyMarshaller();
15 | }
16 |
17 | @Test
18 | public void marshal_strings_to_integers() throws Exception {
19 | String validInput = "5";
20 | int expectedOutput = 5;
21 |
22 | assertThat(integerBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
23 | }
24 |
25 | @Test(expected = IllegalArgumentException.class)
26 | public void throw_exception_when_input_is_invalid() throws Exception {
27 | String invalidInput = "invalid";
28 |
29 | integerBodyMarshaller.marshal(invalidInput);
30 | }
31 |
32 | @Test(expected = IllegalArgumentException.class)
33 | public void throw_exception_when_input_is_float() throws Exception {
34 | String invalidInput = "0.5f";
35 |
36 | integerBodyMarshaller.marshal(invalidInput);
37 | }
38 |
39 | @Test(expected = java.lang.NumberFormatException.class)
40 | public void throw_exception_when_input_is_double() throws Exception {
41 | String invalidInput = "3.5d";
42 |
43 | integerBodyMarshaller.marshal(invalidInput);
44 | }
45 |
46 | @Test(expected = IllegalArgumentException.class)
47 | public void throw_exception_when_input_is_null() throws Exception {
48 | integerBodyMarshaller.marshal(null);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/IntegerWrapperBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.fest.assertions.api.Assertions.assertThat;
6 |
7 | public class IntegerWrapperBodyMarshallerShould {
8 |
9 | @Test
10 | public void marshalStringInput() throws Exception {
11 | IntegerWrapperBodyMarshaller cut = integerWrapperBodyMarshaller(IntegerWrapperClass.class);
12 |
13 | IntegerWrapperClass output = cut.marshal("1");
14 |
15 | assertThat(output).isEqualTo(new IntegerWrapperClass(1));
16 | }
17 |
18 | @Test(expected = RuntimeException.class)
19 | public void onlyWorkForClassesWithAnIntegerConstructorArg() throws Exception {
20 | IntegerWrapperBodyMarshaller cut = integerWrapperBodyMarshaller(StringWrapperClass.class);
21 |
22 | cut.marshal("");
23 | }
24 |
25 | @Test(expected = RuntimeException.class)
26 | public void onlyWorkForClassesWithASingleConstructorArg() throws Exception {
27 | IntegerWrapperBodyMarshaller cut = integerWrapperBodyMarshaller(TwoArgWrapperClass.class);
28 |
29 | cut.marshal("");
30 | }
31 |
32 | @Test(expected = RuntimeException.class)
33 | public void failForClassesWithNoArgConstructor() throws Exception {
34 | IntegerWrapperBodyMarshaller cut = integerWrapperBodyMarshaller(NoArgWrapperClass.class);
35 |
36 | cut.marshal("");
37 | }
38 |
39 | @Test(expected = RuntimeException.class)
40 | public void failForClassesWithPrivateConstructor() throws Exception {
41 | IntegerWrapperBodyMarshaller cut = integerWrapperBodyMarshaller(
42 | PrivateConstructorWrapperClass.class
43 | );
44 |
45 | cut.marshal("1");
46 | }
47 |
48 | private IntegerWrapperBodyMarshaller integerWrapperBodyMarshaller(Class clazz) {
49 | return new IntegerWrapperBodyMarshaller(clazz);
50 | }
51 |
52 | private static class IntegerWrapperClass {
53 | private final int toWrap;
54 |
55 | public IntegerWrapperClass(int toWrap) {
56 | this.toWrap = toWrap;
57 | }
58 |
59 | @Override
60 | public boolean equals(Object o) {
61 | if (this == o) {
62 | return true;
63 | }
64 | if (o == null || getClass() != o.getClass()) {
65 | return false;
66 | }
67 |
68 | IntegerWrapperClass that = (IntegerWrapperClass) o;
69 |
70 | return toWrap == that.toWrap;
71 | }
72 |
73 | @Override
74 | public int hashCode() {
75 | return toWrap;
76 | }
77 | }
78 |
79 | private static class StringWrapperClass {
80 | private StringWrapperClass(String one) {
81 | }
82 | }
83 |
84 | private static class TwoArgWrapperClass {
85 | private TwoArgWrapperClass(int one, int two) {
86 | }
87 | }
88 |
89 | private static class NoArgWrapperClass {
90 | public NoArgWrapperClass() {
91 | }
92 | }
93 |
94 | private static class PrivateConstructorWrapperClass {
95 | private PrivateConstructorWrapperClass(int toWrap) {
96 | }
97 | }
98 |
99 | }
100 |
101 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/LongBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class LongBodyMarshallerShould {
9 |
10 | private LongBodyMarshaller longBodyMarshaller;
11 |
12 | @Before
13 | public void setUp() throws Exception {
14 | longBodyMarshaller = new LongBodyMarshaller();
15 | }
16 |
17 | @Test
18 | public void marshal_integer_strings_to_long() throws Exception {
19 | String validInput = "5";
20 | long expectedOutput = 5;
21 |
22 | assertThat(longBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
23 | }
24 |
25 | @Test
26 | public void marshal_long_strings_to_long() throws Exception {
27 | String validInput = String.valueOf(Long.MAX_VALUE);
28 | long expectedOutput = Long.MAX_VALUE;
29 |
30 | assertThat(longBodyMarshaller.marshal(validInput)).isEqualTo(expectedOutput);
31 | }
32 |
33 | @Test(expected = IllegalArgumentException.class)
34 | public void throw_exception_when_input_is_invalid() throws Exception {
35 | String invalidInput = "invalid";
36 |
37 | longBodyMarshaller.marshal(invalidInput);
38 | }
39 |
40 | @Test(expected = IllegalArgumentException.class)
41 | public void throw_exception_when_input_is_float() throws Exception {
42 | String invalidInput = "0.5f";
43 |
44 | longBodyMarshaller.marshal(invalidInput);
45 | }
46 |
47 | @Test(expected = NumberFormatException.class)
48 | public void throw_exception_when_input_is_double() throws Exception {
49 | String invalidInput = "3.5d";
50 |
51 | longBodyMarshaller.marshal(invalidInput);
52 | }
53 |
54 | @Test(expected = IllegalArgumentException.class)
55 | public void throw_exception_when_input_is_null() throws Exception {
56 | longBodyMarshaller.marshal(null);
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/LongWrapperBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.fest.assertions.api.Assertions.assertThat;
6 |
7 | public class LongWrapperBodyMarshallerShould {
8 |
9 | @Test
10 | public void marshalStringInput() throws Exception {
11 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(LongWrapperClass.class);
12 |
13 | LongWrapperClass output = cut.marshal(String.valueOf(Long.MAX_VALUE));
14 |
15 | assertThat(output).isEqualTo(new LongWrapperClass(Long.MAX_VALUE));
16 | }
17 |
18 | @Test(expected = RuntimeException.class)
19 | public void onlyWorkForClassesWithALongConstructorArgString() throws Exception {
20 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(StringWrapperClass.class);
21 |
22 | cut.marshal("");
23 | }
24 |
25 | @Test(expected = RuntimeException.class)
26 | public void onlyWorkForClassesWithALongConstructorArgInteger() throws Exception {
27 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(IntegerWrapperClass.class);
28 |
29 | cut.marshal("");
30 | }
31 |
32 | @Test(expected = RuntimeException.class)
33 | public void onlyWorkForClassesWithASingleConstructorArg() throws Exception {
34 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(TwoArgWrapperClass.class);
35 |
36 | cut.marshal("");
37 | }
38 |
39 | @Test(expected = RuntimeException.class)
40 | public void failForClassesWithNoArgConstructor() throws Exception {
41 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(NoArgWrapperClass.class);
42 |
43 | cut.marshal("");
44 | }
45 |
46 | @Test(expected = RuntimeException.class)
47 | public void failForClassesWithPrivateConstructor() throws Exception {
48 | LongWrapperBodyMarshaller cut = longWrapperBodyMarshaller(
49 | PrivateConstructorWrapperClass.class
50 | );
51 |
52 | cut.marshal("1");
53 | }
54 |
55 | private LongWrapperBodyMarshaller longWrapperBodyMarshaller(Class clazz) {
56 | return new LongWrapperBodyMarshaller(clazz);
57 | }
58 |
59 | private static class LongWrapperClass {
60 | private final long toWrap;
61 |
62 | public LongWrapperClass(long toWrap) {
63 | this.toWrap = toWrap;
64 | }
65 |
66 | @Override
67 | public boolean equals(Object o) {
68 | if (this == o) {
69 | return true;
70 | }
71 | if (o == null || getClass() != o.getClass()) {
72 | return false;
73 | }
74 |
75 | LongWrapperClass that = (LongWrapperClass) o;
76 |
77 | return toWrap == that.toWrap;
78 | }
79 |
80 | @Override
81 | public int hashCode() {
82 | return (int) (toWrap ^ (toWrap >>> 32));
83 | }
84 | }
85 |
86 | private static class IntegerWrapperClass {
87 | private IntegerWrapperClass(int one) {
88 | }
89 | }
90 |
91 | private static class StringWrapperClass {
92 | private StringWrapperClass(String one) {
93 | }
94 | }
95 |
96 | private static class TwoArgWrapperClass {
97 | private TwoArgWrapperClass(long one, long two) {
98 | }
99 | }
100 |
101 | private static class NoArgWrapperClass {
102 | public NoArgWrapperClass() {
103 | }
104 | }
105 |
106 | private static class PrivateConstructorWrapperClass {
107 | private PrivateConstructorWrapperClass(long toWrap) {
108 | }
109 | }
110 |
111 | }
112 |
113 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/StringBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 |
6 | import static org.fest.assertions.api.Assertions.assertThat;
7 |
8 | public class StringBodyMarshallerShould {
9 |
10 | StringBodyMarshaller stringBodyMarshaller;
11 |
12 | @Before
13 | public void setUp() {
14 | stringBodyMarshaller = new StringBodyMarshaller();
15 | }
16 |
17 | @Test
18 | public void marshalTheString() throws Exception {
19 | String theInput = "theInput";
20 |
21 | assertThat(stringBodyMarshaller.marshal(theInput)).isEqualTo(theInput);
22 | }
23 |
24 | @Test
25 | public void marshalNull() throws Exception {
26 | assertThat(stringBodyMarshaller.marshal(null)).isEqualTo(null);
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/marshaller/StringWrapperBodyMarshallerShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.marshaller;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.fest.assertions.api.Assertions.assertThat;
6 |
7 | public class StringWrapperBodyMarshallerShould {
8 |
9 | @Test
10 | public void marshalStringInput() throws Exception {
11 | StringWrapperBodyMarshaller cut = stringWrapperBodyMarshaller(StringWrapperClass.class);
12 |
13 | String testInput = "testInput";
14 | StringWrapperClass output = cut.marshal(testInput);
15 |
16 | assertThat(output).isEqualTo(new StringWrapperClass(testInput));
17 | }
18 |
19 | @Test(expected = RuntimeException.class)
20 | public void onlyWorkForClassesWithASingleStringConstructorArg() throws Exception {
21 | StringWrapperBodyMarshaller cut = stringWrapperBodyMarshaller(IntegerWrapperClass.class);
22 |
23 | cut.marshal("");
24 | }
25 |
26 | @Test(expected = RuntimeException.class)
27 | public void onlyWorkForClassesWithASingleConstructorArg() throws Exception {
28 | StringWrapperBodyMarshaller cut = stringWrapperBodyMarshaller(TwoArgWrapperClass.class);
29 |
30 | cut.marshal("");
31 | }
32 |
33 | private StringWrapperBodyMarshaller stringWrapperBodyMarshaller(Class clazz) {
34 | return new StringWrapperBodyMarshaller(clazz);
35 | }
36 |
37 | private static class StringWrapperClass {
38 | private final String toWrap;
39 |
40 | public StringWrapperClass(String toWrap) {
41 | this.toWrap = toWrap;
42 | }
43 |
44 | @Override
45 | public boolean equals(Object o) {
46 | if (this == o) {
47 | return true;
48 | }
49 | if (o == null || getClass() != o.getClass()) {
50 | return false;
51 | }
52 |
53 | StringWrapperClass that = (StringWrapperClass) o;
54 |
55 | return !(toWrap != null ? !toWrap.equals(that.toWrap) : that.toWrap != null);
56 | }
57 |
58 | @Override
59 | public int hashCode() {
60 | return toWrap != null ? toWrap.hashCode() : 0;
61 | }
62 | }
63 |
64 | private static class IntegerWrapperClass {
65 | private IntegerWrapperClass(Integer one) {
66 | }
67 | }
68 |
69 | private static class TwoArgWrapperClass {
70 | private TwoArgWrapperClass(String one, String two) {
71 | }
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/sexp/src/test/java/com/novoda/sexp/parser/BasicAttributeParserShould.java:
--------------------------------------------------------------------------------
1 | package com.novoda.sexp.parser;
2 |
3 | import com.novoda.sax.Element;
4 | import com.novoda.sexp.marshaller.AttributeMarshaller;
5 |
6 | import org.junit.Before;
7 | import org.junit.Test;
8 | import org.mockito.Mock;
9 | import org.xml.sax.Attributes;
10 |
11 | import static org.mockito.Mockito.*;
12 | import static org.mockito.MockitoAnnotations.initMocks;
13 |
14 | public class BasicAttributeParserShould {
15 |
16 | private static final String ATTR_TAG = "attrTag";
17 | private static final String FOUND_ATTRIBUTE = "foundAttribute";
18 |
19 | @Mock
20 | private AttributeMarshaller mockMarshaller;
21 | @Mock
22 | private ParseWatcher mockParseWatcher;
23 | private BasicAttributeParser