br.ufrj.ppgi.greco.kettle.silk.Silk - Code Metrics - Inspection of "feat: add silk linking tool :squirrel:" - johncurcio/ETL4LODPlus - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 549d98...451709 )

by John

created 2018-11-04 22:00 UTC

br.ufrj.ppgi.greco.kettle.silk.Silk A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
wmc	31
eloc	118
c	1
b	0
f	1
dl	0
loc	180
rs	9.92

12 Methods

Rating	Name	Size	Complexity
A	setOutputs(LinkDiscoveryToolStepMeta)	12	2
A	getMetrics(LinkDiscoveryToolStepMeta)	11	2
A	Silk(LinkDiscoveryToolStepMeta)	5	1
A	createAggregation(LinkDiscoveryToolStepMeta)	8	2
B	setDataSource(LinkDiscoveryToolStepMeta,String,String,String,String)	23	7
A	Silk()	1	1
A	setDataSources(LinkDiscoveryToolStepMeta)	13	3
A	getFileFormat(String)	10	5
A	setPrefixes(LinkDiscoveryToolStepMeta)	7	2
A	getLinkageRule(LinkDiscoveryToolStepMeta)	8	3
A	main(String[])	10	2
A	setInterlinks(LinkDiscoveryToolStepMeta)	8	1

package br.ufrj.ppgi.greco.kettle.silk;

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

import org.pentaho.di.core.Const;

import br.ufrj.ppgi.greco.kettle.LinkDiscoveryToolStepMeta;

@XmlRootElement(name = "Silk")
public class Silk {

	@XmlElement(name = "Prefixes")
	protected Prefixes prefixes = new Prefixes();

	@XmlElement(name = "DataSources")
	protected Datasets dataSources = new Datasets();

	@XmlElement(name = "Interlinks")
	protected Interlinks interlinks = new Interlinks();

	@XmlElement(name = "Outputs")
	protected Datasets outputs = new Datasets();

	public Silk() {
	}

	public Silk(LinkDiscoveryToolStepMeta input) {
		this.setPrefixes(input);
		this.setDataSources(input);
		this.setInterlinks(input);
		this.setOutputs(input);
	}

	/**
	 * Set the <Prefixes> tag in the Silk SLS file
	 * 
	 * @param input
	 *            information given by the user on Kettle
	 */
	public void setPrefixes(LinkDiscoveryToolStepMeta input) {
		final int PREFIX = 0;
		final int NAMESPACE = 1;
		for (int i = 0; i < input.getPrefixes().size(); i++) {
			List<String> prefix = input.getPrefixes().getRow(i);
			Prefix p = new Prefix(prefix.get(PREFIX), prefix.get(NAMESPACE));
			this.prefixes.add(p);
		}
	}

	/**
	 * Set the <DataSources> tag in the Silk SLS file
	 * 
	 * @param input
	 *            information given by the user on Kettle
	 */
	public void setDataSources(LinkDiscoveryToolStepMeta input) {
		if (input.isSparqlEndpoint(input.getSourceEndpoint())) {
			setDataSource(input, Dataset.SPARQL, "source", input.getSourceEndpoint(), input.getSourceGraph());
		} else {
			setDataSource(input, input.getFileType(input.getSourceEndpoint()), "source", input.getSourceEndpoint(),
					input.getSourceGraph());
		}

		if (input.isSparqlEndpoint(input.getTargetEndpoint())) {
			setDataSource(input, Dataset.SPARQL, "target", input.getTargetEndpoint(), input.getTargetGraph());
		} else {
			setDataSource(input, input.getFileType(input.getTargetEndpoint()), "target", input.getTargetEndpoint(),
					input.getTargetGraph());
		}
	}

	private String getFileFormat(String fileType) {
		switch (fileType) {
		case "rdf":
			return "RDF/XML";
		case "ttl":
			return "Turtle";
		case "nt":
			return "N-Triples";
		default:
			return "RDF/XML";
		}
	}

	public void setDataSource(LinkDiscoveryToolStepMeta input, String type, String id, String endpoint, String graph) {
		Dataset source = null;
		switch (type) {
		case Dataset.SPARQL:
			source = new Dataset(id, Dataset.SPARQL);
			source.add(new Param("endpointURI", Const.NVL(endpoint, "")));
			source.add(new Param("graph", Const.NVL(graph, "")));
			break;
		case "rdf":
		case "ttl":
		case "nt":
			source = new Dataset(id, Dataset.RDF);
			source.add(new Param("file", Const.NVL(endpoint, "")));
			source.add(new Param("format", Const.NVL(getFileFormat(type), "")));
			source.add(new Param("graph", Const.NVL(graph, "")));
			break;
		case "csv":
		case "xml":
			source = new Dataset(id, type);
			source.add(new Param("file", Const.NVL(endpoint, "")));
			break;
		}
		this.dataSources.add(source);
	}

	/**
	 * Set the <Interlinks> tag in the Silk SLS file
	 * 
	 * @param input
	 *            information given by the user on Kettle
	 */
	public void setInterlinks(LinkDiscoveryToolStepMeta input) {
		DataSource src = new DataSource("source", "a", input.getSourceRestriction());
		DataSource tgt = new DataSource("target", "b", input.getTargetRestriction());
		LinkageRule link = getLinkageRule(input);
		Outputs outputs = new Outputs();
		outputs.addOutput(new Output("output"));
		Interlink interlink = new Interlink("link", src, tgt, link, outputs);
		this.interlinks.add(interlink);
	}

	/**
	 * Set the <Outputs> tag in the Silk SLS file
	 * 
	 * @param input
	 *            information given by the user on Kettle
	 */
	public void setOutputs(LinkDiscoveryToolStepMeta input) {
		Dataset output = null;
		if (input.isSparqlOutput()){
			output = new Dataset("output", Dataset.SPARQL);
			output.add(new Param("endpointURI", Const.NVL(input.getOutputEndpoint(), "")));
			output.add(new Param("graph", Const.NVL(input.getOutputGraph(), "")));
		}else{
			output = new Dataset("output", "file");
			output.add(new Param("file", input.getFilePath()));
			output.add(new Param("format", "N-Triples"));
		}
		this.outputs.add(output);
	}
	
	public List<Metric> getMetrics(LinkDiscoveryToolStepMeta input){
		final int SOURCE_PATH = 0, TARGET_PATH = 1, METRIC = 2;
		List<Metric> metricList = new ArrayList<>();
		for (int i = 0; i < input.getMetrics().size(); i++) {
			List<String> metrics = input.getMetrics().getRow(i);
			Metric metric = new Metric(i+1, metrics.get(METRIC));
			metric.addInput(new Input("sourcePath" + (i+1), metrics.get(SOURCE_PATH)));
			metric.addInput(new Input("targetPath" + (i+1), metrics.get(TARGET_PATH)));
			metricList.add(metric);
		}
		return metricList;
	}

	public Aggregate createAggregation(LinkDiscoveryToolStepMeta input) {
		Aggregate aggregation = null;
		boolean hasNoAggregation = input.getMetrics() == null || input.getMetrics().size() == 0 || input.getMetrics().getValue(0, 2).isEmpty();
		if (!hasNoAggregation) {
			aggregation = new Aggregate(input.getAggregationType(), input.getAggregationType());
			aggregation.setMetrics(getMetrics(input));
		}
		return aggregation;
	}
	
	private LinkageRule getLinkageRule(LinkDiscoveryToolStepMeta input) {
		LinkageRule link = new LinkageRule(input.getLinkageType());
		if (input.getAggregationType() == null || input.getAggregationType().equals("")){
			link.setMetrics(getMetrics(input));
		} else {
			link = new LinkageRule(input.getLinkageType(), createAggregation(input));
		}
		return link;
	}

	public static void main(String[] args) {
		LinkDiscoveryToolStepMeta input = new LinkDiscoveryToolStepMeta();
		Silk s = new Silk(input);
		try {
			JAXBContext context = JAXBContext.newInstance(Silk.class);
			Marshaller m = context.createMarshaller();
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
			m.marshal(s, System.out);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

1			package br.ufrj.ppgi.greco.kettle.silk;
2
3			import java.util.ArrayList;
4			import java.util.List;
5
6			import javax.xml.bind.JAXBContext;
7			import javax.xml.bind.Marshaller;
8			import javax.xml.bind.annotation.XmlElement;
9			import javax.xml.bind.annotation.XmlRootElement;
10
11			import org.pentaho.di.core.Const;
12
13			import br.ufrj.ppgi.greco.kettle.LinkDiscoveryToolStepMeta;
14
15			@XmlRootElement(name = "Silk")
16			public class Silk {
17
18			@XmlElement(name = "Prefixes")
19			protected Prefixes prefixes = new Prefixes();
20
21			@XmlElement(name = "DataSources")
22			protected Datasets dataSources = new Datasets();
23
24			@XmlElement(name = "Interlinks")
25			protected Interlinks interlinks = new Interlinks();
26
27			@XmlElement(name = "Outputs")
28			protected Datasets outputs = new Datasets();
29
30			public Silk() {
31			}
32
33			public Silk(LinkDiscoveryToolStepMeta input) {
34			this.setPrefixes(input);
35			this.setDataSources(input);
36			this.setInterlinks(input);
37			this.setOutputs(input);
38			}
39
40			/**
41			* Set the <Prefixes> tag in the Silk SLS file
42			*
43			* @param input
44			* information given by the user on Kettle
45			*/
46			public void setPrefixes(LinkDiscoveryToolStepMeta input) {
47			final int PREFIX = 0;
48			final int NAMESPACE = 1;
49			for (int i = 0; i < input.getPrefixes().size(); i++) {
50			List<String> prefix = input.getPrefixes().getRow(i);
51			Prefix p = new Prefix(prefix.get(PREFIX), prefix.get(NAMESPACE));
52			this.prefixes.add(p);
53			}
54			}
55
56			/**
57			* Set the <DataSources> tag in the Silk SLS file
58			*
59			* @param input
60			* information given by the user on Kettle
61			*/
62			public void setDataSources(LinkDiscoveryToolStepMeta input) {
63			if (input.isSparqlEndpoint(input.getSourceEndpoint())) {
64			setDataSource(input, Dataset.SPARQL, "source", input.getSourceEndpoint(), input.getSourceGraph());
65			} else {
66			setDataSource(input, input.getFileType(input.getSourceEndpoint()), "source", input.getSourceEndpoint(),
67			input.getSourceGraph());
68			}
69
70			if (input.isSparqlEndpoint(input.getTargetEndpoint())) {
71			setDataSource(input, Dataset.SPARQL, "target", input.getTargetEndpoint(), input.getTargetGraph());
72			} else {
73			setDataSource(input, input.getFileType(input.getTargetEndpoint()), "target", input.getTargetEndpoint(),
74			input.getTargetGraph());
75			}
76			}
77
78			private String getFileFormat(String fileType) {
79			switch (fileType) {
80			case "rdf":
81			return "RDF/XML";
82			case "ttl":
83			return "Turtle";
84			case "nt":
85			return "N-Triples";
86			default:
87			return "RDF/XML";
88			}
89			}
90
91			public void setDataSource(LinkDiscoveryToolStepMeta input, String type, String id, String endpoint, String graph) {
92			Dataset source = null;
93			switch (type) {
94			case Dataset.SPARQL:
95			source = new Dataset(id, Dataset.SPARQL);
96			source.add(new Param("endpointURI", Const.NVL(endpoint, "")));
97			source.add(new Param("graph", Const.NVL(graph, "")));
98			break;
99			case "rdf":
100			case "ttl":
101			case "nt":
102			source = new Dataset(id, Dataset.RDF);
103			source.add(new Param("file", Const.NVL(endpoint, "")));
104			source.add(new Param("format", Const.NVL(getFileFormat(type), "")));
105			source.add(new Param("graph", Const.NVL(graph, "")));
106			break;
107			case "csv":
108			case "xml":
109			source = new Dataset(id, type);
110			source.add(new Param("file", Const.NVL(endpoint, "")));
111			break;
112			}
113			this.dataSources.add(source);
114			}
115
116			/**
117			* Set the <Interlinks> tag in the Silk SLS file
118			*
119			* @param input
120			* information given by the user on Kettle
121			*/
122			public void setInterlinks(LinkDiscoveryToolStepMeta input) {
123			DataSource src = new DataSource("source", "a", input.getSourceRestriction());
124			DataSource tgt = new DataSource("target", "b", input.getTargetRestriction());
125			LinkageRule link = getLinkageRule(input);
126			Outputs outputs = new Outputs();
127			outputs.addOutput(new Output("output"));
128			Interlink interlink = new Interlink("link", src, tgt, link, outputs);
129			this.interlinks.add(interlink);
130			}
131
132			/**
133			* Set the <Outputs> tag in the Silk SLS file
134			*
135			* @param input
136			* information given by the user on Kettle
137			*/
138			public void setOutputs(LinkDiscoveryToolStepMeta input) {
139			Dataset output = null;
140			if (input.isSparqlOutput()){
141			output = new Dataset("output", Dataset.SPARQL);
142			output.add(new Param("endpointURI", Const.NVL(input.getOutputEndpoint(), "")));
143			output.add(new Param("graph", Const.NVL(input.getOutputGraph(), "")));
144			}else{
145			output = new Dataset("output", "file");
146			output.add(new Param("file", input.getFilePath()));
147			output.add(new Param("format", "N-Triples"));
148			}
149			this.outputs.add(output);
150			}
151
152			public List<Metric> getMetrics(LinkDiscoveryToolStepMeta input){
153			final int SOURCE_PATH = 0, TARGET_PATH = 1, METRIC = 2;
154			List<Metric> metricList = new ArrayList<>();
155			for (int i = 0; i < input.getMetrics().size(); i++) {
156			List<String> metrics = input.getMetrics().getRow(i);
157			Metric metric = new Metric(i+1, metrics.get(METRIC));
158			metric.addInput(new Input("sourcePath" + (i+1), metrics.get(SOURCE_PATH)));
159			metric.addInput(new Input("targetPath" + (i+1), metrics.get(TARGET_PATH)));
160			metricList.add(metric);
161			}
162			return metricList;
163			}
164
165			public Aggregate createAggregation(LinkDiscoveryToolStepMeta input) {
166			Aggregate aggregation = null;
167			boolean hasNoAggregation = input.getMetrics() == null \|\| input.getMetrics().size() == 0 \|\| input.getMetrics().getValue(0, 2).isEmpty();
168			if (!hasNoAggregation) {
169			aggregation = new Aggregate(input.getAggregationType(), input.getAggregationType());
170			aggregation.setMetrics(getMetrics(input));
171			}
172			return aggregation;
173			}
174
175			private LinkageRule getLinkageRule(LinkDiscoveryToolStepMeta input) {
176			LinkageRule link = new LinkageRule(input.getLinkageType());
177			if (input.getAggregationType() == null \|\| input.getAggregationType().equals("")){
178			link.setMetrics(getMetrics(input));
179			} else {
180			link = new LinkageRule(input.getLinkageType(), createAggregation(input));
181			}
182			return link;
183			}
184
185			public static void main(String[] args) {
186			LinkDiscoveryToolStepMeta input = new LinkDiscoveryToolStepMeta();
187			Silk s = new Silk(input);
188			try {
189			JAXBContext context = JAXBContext.newInstance(Silk.class);
190			Marshaller m = context.createMarshaller();
191			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
192			m.marshal(s, System.out);
193			} catch (Exception e) {
194			e.printStackTrace();
195			}
196			}
197
198			}

johncurcio / ETL4LODPlus

Push — master ( 549d98...451709 )

br.ufrj.ppgi.greco.kettle.silk.Silk A

Complexity

Size/Duplication

Importance

12 Methods

Duplication Side-by-Side

Filter issues like