OSDN Git Service

Vmd2XMLと共通化
[mikutoga/Pmd2XML.git] / src / main / java / jp / sfjp / mikutoga / pmd2xml / Pmd2XmlConv.java
1 /*
2  * pmd 2 xml converter
3  *
4  * License : The MIT License
5  * Copyright(c) 2010 MikuToga Partners
6  */
7
8 package jp.sfjp.mikutoga.pmd2xml;
9
10 import java.io.IOException;
11 import java.io.InputStream;
12 import java.io.OutputStream;
13 import javax.xml.parsers.DocumentBuilder;
14 import javax.xml.parsers.DocumentBuilderFactory;
15 import javax.xml.parsers.ParserConfigurationException;
16 import javax.xml.validation.Schema;
17 import jp.sfjp.mikutoga.bin.parser.MmdFormatException;
18 import jp.sfjp.mikutoga.pmd.IllegalPmdDataException;
19 import jp.sfjp.mikutoga.pmd.binio.PmdExporter;
20 import jp.sfjp.mikutoga.pmd.binio.PmdLoader;
21 import jp.sfjp.mikutoga.pmd.model.PmdModel;
22 import jp.sfjp.mikutoga.pmd.xml.Schema101009;
23 import jp.sfjp.mikutoga.pmd.xml.Schema130128;
24 import jp.sfjp.mikutoga.pmd.xml.XmlExporter;
25 import jp.sfjp.mikutoga.pmd.xml.XmlLoader;
26 import jp.sfjp.mikutoga.pmd.xml.XmlModelFileType;
27 import jp.sourceforge.mikutoga.xml.BotherHandler;
28 import jp.sourceforge.mikutoga.xml.LocalXmlResource;
29 import jp.sourceforge.mikutoga.xml.SchemaUtil;
30 import jp.sourceforge.mikutoga.xml.TogaXmlException;
31 import jp.sourceforge.mikutoga.xml.XmlResourceResolver;
32 import org.xml.sax.InputSource;
33 import org.xml.sax.SAXException;
34
35 /**
36  * PMD-XML間コンバータ本体。
37  */
38 public class Pmd2XmlConv {
39
40     private ModelFileType inTypes  = ModelFileType.NONE;
41     private ModelFileType outTypes = ModelFileType.NONE;
42     private String newLine = "\r\n";
43     private String generator = null;
44
45
46     /**
47      * コンストラクタ。
48      */
49     public Pmd2XmlConv(){
50         super();
51         return;
52     }
53
54
55     /**
56      * ドキュメントビルダファクトリを初期化する。
57      * @param builderFactory ドキュメントビルダファクトリ
58      */
59     private static void initBuilderFactory(
60             DocumentBuilderFactory builderFactory ){
61         builderFactory.setCoalescing(true);
62         builderFactory.setExpandEntityReferences(true);
63         builderFactory.setIgnoringComments(true);
64         builderFactory.setIgnoringElementContentWhitespace(false);
65         builderFactory.setNamespaceAware(true);
66         builderFactory.setValidating(false);
67         builderFactory.setXIncludeAware(false);
68
69 //      builderFactory.setFeature(name, value);
70 //      builderFactory.setAttribute(name, value);
71
72         return;
73     }
74
75     /**
76      * DOMビルダ生成。
77      * @return DOMビルダ
78      */
79     private DocumentBuilder buildBuilder(){
80         XmlResourceResolver resolver = new XmlResourceResolver();
81
82         LocalXmlResource[] schemaArray;
83         switch(this.inTypes){
84         case XML_101009:
85             schemaArray = new LocalXmlResource[]{
86                 Schema101009.SINGLETON,
87             };
88             break;
89         case XML_130128:
90             schemaArray = new LocalXmlResource[]{
91                 Schema130128.SINGLETON,
92             };
93             break;
94         case XML_AUTO:
95             schemaArray = new LocalXmlResource[]{
96                 Schema101009.SINGLETON,
97                 Schema130128.SINGLETON,
98             };
99             break;
100         default:
101             throw new IllegalStateException();
102         }
103
104         Schema schema = SchemaUtil.newSchema(resolver, schemaArray);
105
106         DocumentBuilderFactory builderFactory =
107                 DocumentBuilderFactory.newInstance();
108         initBuilderFactory(builderFactory);
109         builderFactory.setSchema(schema);
110
111         DocumentBuilder result;
112         try{
113             result = builderFactory.newDocumentBuilder();
114         }catch(ParserConfigurationException e){
115             assert false;
116             throw new AssertionError(e);
117         }
118         result.setEntityResolver(resolver);
119         result.setErrorHandler(BotherHandler.HANDLER);
120
121         return result;
122     }
123
124
125     /**
126      * 入力ファイル種別を設定する。
127      * @param type ファイル種別
128      * @throws NullPointerException 引数がnull
129      * @throws IllegalArgumentException 具体的な種別を渡さなかった
130      */
131     public void setInType(ModelFileType type)
132             throws NullPointerException, IllegalArgumentException {
133         if(type == null) throw new NullPointerException();
134         if(type == ModelFileType.NONE) throw new IllegalArgumentException();
135         this.inTypes = type;
136         return;
137     }
138
139     /**
140      * 入力ファイル種別を返す。
141      * @return ファイル種別
142      */
143     public ModelFileType getInTypes(){
144         return this.inTypes;
145     }
146
147     /**
148      * 出力ファイル種別を設定する。
149      * @param type ファイル種別
150      * @throws NullPointerException 引数がnull
151      * @throws IllegalArgumentException 具体的な種別を渡さなかった
152      */
153     public void setOutType(ModelFileType type)
154             throws NullPointerException, IllegalArgumentException {
155         if(type == null) throw new NullPointerException();
156         if(type == ModelFileType.NONE) throw new IllegalArgumentException();
157         this.outTypes = type;
158         return;
159     }
160
161     /**
162      * 出力ファイル種別を返す。
163      * @return ファイル種別
164      */
165     public ModelFileType getOutTypes(){
166         return this.outTypes;
167     }
168
169     /**
170      * XML出力用改行文字列を設定する。
171      * @param newline 改行文字
172      */
173     public void setNewline(String newline){
174         this.newLine = newline;
175         return;
176     }
177
178     /**
179      * XML出力用改行文字列を返す。
180      * @return 改行文字
181      */
182     public String getNewline(){
183         return this.newLine;
184     }
185
186     /**
187      * ジェネレータ名を設定する。
188      * @param generator ジェネレータ名。表示したくない場合はnull
189      */
190     public void setGenerator(String generator){
191         this.generator = generator;
192         return;
193     }
194
195     /**
196      * ジェネレータ名を返す。
197      * @return ジェネレータ名。非表示の場合はnullを返す。
198      */
199     public String getGenerator(){
200         return this.generator;
201     }
202
203     /**
204      * ファイル変換を行う。
205      * @param is 入力ストリーム
206      * @param os 出力ストリーム
207      * @throws IOException 入力エラー
208      * @throws MmdFormatException フォーマットエラー
209      * @throws SAXException XMLエラー
210      * @throws TogaXmlException XMLエラー
211      * @throws IllegalPmdDataException 内部エラー
212      */
213     public void convert(InputStream is, OutputStream os)
214             throws IOException,
215                    MmdFormatException,
216                    SAXException,
217                    TogaXmlException,
218                    IllegalPmdDataException {
219         PmdModel model = readModel(is);
220         writeModel(model, os);
221         return;
222     }
223
224     /**
225      * モデルファイルを読み込む。
226      * @param is 入力ストリーム
227      * @return モデルデータ
228      * @throws IOException 入力エラー
229      * @throws MmdFormatException フォーマットエラー
230      * @throws SAXException XMLエラー
231      * @throws TogaXmlException XMLエラー
232      */
233     public PmdModel readModel(InputStream is)
234             throws IOException,
235                    MmdFormatException,
236                    SAXException,
237                    TogaXmlException {
238         PmdModel model = null;
239
240         if(this.inTypes.isPmd()){
241             model = pmdRead(is);
242         }else if(this.inTypes.isXml()){
243             model = xmlRead(is);
244         }else{
245             throw new IllegalStateException();
246         }
247
248         return model;
249     }
250
251     /**
252      * モデルファイルを出力する。
253      * @param model モデルデータ
254      * @param os 出力ストリーム
255      * @throws IOException 出力エラー
256      * @throws IllegalPmdDataException データの不備
257      */
258     public void writeModel(PmdModel model, OutputStream os)
259             throws IOException,
260                    IllegalPmdDataException {
261         if(this.outTypes.isPmd()){
262             pmdOut(model, os);
263         }else if(this.outTypes.isXml()){
264             xmlOut(model, os);
265         }else{
266             throw new IllegalStateException();
267         }
268
269         return;
270     }
271
272     /**
273      * PMDファイルからモデルデータを読み込む。
274      * @param is 入力ストリーム
275      * @return モデルデータ
276      * @throws IOException 入力エラー
277      * @throws MmdFormatException 不正なPMDファイルフォーマット
278      */
279     private PmdModel pmdRead(InputStream is)
280             throws IOException, MmdFormatException{
281         PmdLoader loader = new PmdLoader();
282         PmdModel model = loader.load(is);
283         return model;
284     }
285
286     /**
287      * XMLファイルからモデルデータを読み込む。
288      * @param is 入力ストリーム
289      * @return モデルデータ
290      * @throws IOException 入力エラー
291      * @throws SAXException XML構文エラー
292      * @throws TogaXmlException 不正なXMLデータ
293      */
294     private PmdModel xmlRead(InputStream is)
295             throws IOException,
296                    SAXException,
297                    TogaXmlException {
298         InputSource source = new InputSource(is);
299         PmdModel result = xmlRead(source);
300         return result;
301     }
302
303     /**
304      * XMLファイルからモデルデータを読み込む。
305      * @param source 入力ソース
306      * @return モデルデータ
307      * @throws IOException 入力エラー
308      * @throws SAXException XML構文エラー
309      * @throws TogaXmlException 不正なXMLデータ
310      */
311     private PmdModel xmlRead(InputSource source)
312             throws IOException,
313                    SAXException,
314                    TogaXmlException {
315         DocumentBuilder builder = buildBuilder();
316         XmlLoader loader = new XmlLoader();
317         PmdModel model = loader.parse(builder, source);
318         return model;
319     }
320
321     /**
322      * モデルデータをPMDファイルに出力する。
323      * @param model モデルデータ
324      * @param ostream 出力ストリーム
325      * @throws IOException 出力エラー
326      * @throws IllegalPmdDataException 不正なモデルデータ
327      */
328     private void pmdOut(PmdModel model, OutputStream ostream)
329             throws IOException, IllegalPmdDataException{
330         PmdExporter exporter = new PmdExporter(ostream);
331         exporter.dumpPmdModel(model);
332         ostream.close();
333         return;
334     }
335
336     /**
337      * モデルデータをXMLファイルに出力する。
338      * @param model モデルデータ
339      * @param ostream 出力ストリーム
340      * @throws IOException 出力エラー
341      * @throws IllegalPmdDataException 不正なモデルデータ
342      */
343     private void xmlOut(PmdModel model, OutputStream ostream)
344             throws IOException, IllegalPmdDataException{
345         XmlExporter exporter = new XmlExporter(ostream);
346
347         XmlModelFileType xmlType = this.outTypes.toXmlType();
348         exporter.setXmlFileType(xmlType);
349         exporter.setNewLine(this.newLine);
350         exporter.setGenerator(this.generator);
351
352         exporter.putPmdModel(model);
353
354         exporter.close();
355
356         return;
357     }
358
359 }