@Override public <T extends ExecutableRule<?>> boolean accepts(T executableRule) { return executableRule.getExecutable() instanceof SourceExecutable; }
private String getPrimaryColumn(ExecutableRule rule, List<String> columnNames) { String primaryColumn = rule.getReport().getPrimaryColumn(); if (primaryColumn == null && columnNames != null && !columnNames.isEmpty()) { primaryColumn = columnNames.get(0); } return primaryColumn; }
@Override public void run() throws XMLStreamException { xmlStreamWriter.writeStartElement(elementName); xmlStreamWriter.writeAttribute("id", rule.getId()); xmlStreamWriter.writeStartElement("description"); xmlStreamWriter.writeCharacters(rule.getDescription());
private void writeRequiredConcepts(ExecutableRule<?> rule, ExecutableRuleType ruleType) { for (Map.Entry<String, Boolean> entry : rule.getRequiresConcepts().entrySet()) { ReferenceType conceptReferenceType = new ReferenceType(); conceptReferenceType.setRefId(entry.getKey()); conceptReferenceType.setOptional(entry.getValue()); ruleType.getRequiresConcept().add(conceptReferenceType); } }
private Map<String, Object> getRuleParameters(ExecutableRule executableRule) throws RuleException { Map<String, Object> ruleParameters = new HashMap<>(); Map<String, Parameter> parameters = executableRule.getParameters(); for (Map.Entry<String, Parameter> entry : parameters.entrySet()) { String parameterName = entry.getKey(); Parameter parameter = entry.getValue(); Object parameterValue; String parameterValueAsString = this.ruleParameters.get(parameterName); if (parameterValueAsString != null) { try { parameterValue = parameter.getType().parse(parameterValueAsString); } catch (RuleException e) { throw new RuleException("Cannot determine value for parameter " + parameterName + "' of rule '" + executableRule + "'."); } } else { parameterValue = parameter.getDefaultValue(); } if (parameterValue == null) { throw new RuleException("No value or default value defined for required parameter '" + parameterName + "' of rule '" + executableRule + "'."); } ruleParameters.put(parameterName, parameterValue); } return ruleParameters; }
if (Result.Status.FAILURE.equals(result.getStatus())) { ExecutableRule rule = result.getRule(); String severityInfo = rule.getSeverity().getInfo(result.getSeverity()); List<String> resultRows = getResultRows(result, logResult);
private boolean applyRequiredConcepts(RuleSet ruleSet, ExecutableRule<?> rule) throws RuleException { boolean requiredConceptsApplied = true; for (Map.Entry<String, Boolean> entry : rule.getRequiresConcepts().entrySet()) { List<Concept> requiredConcepts = ruleSet.getConceptBucket().match(entry.getKey()); for (Concept requiredConcept : requiredConcepts) { boolean conceptResult = applyConcept(ruleSet, requiredConcept, requiredConcept.getSeverity()); Boolean optional = entry.getValue(); if (optional == null) { optional = configuration.isRequiredConceptsAreOptionalByDefault(); } requiredConceptsApplied = requiredConceptsApplied && (conceptResult || optional); } } return requiredConceptsApplied; }
@Override public <T extends ExecutableRule<?>> boolean accepts(T executableRule) { return executableRule.getExecutable() instanceof SourceExecutable; }
/** * Select the report writers for the given rule. * * @param rule * The rule. * @throws ReportException * If no writer exists for a specified id. */ private Map<String, ReportPlugin> selectReportPlugins(ExecutableRule rule) throws ReportException { Set<String> selection = rule.getReport().getSelectedTypes(); Map<String, ReportPlugin> reportPlugins = new HashMap<>(); if (selection != null) { for (String type : selection) { ReportPlugin candidate = this.selectableReportPlugins.get(type); if (candidate == null) { throw new ReportException("Unknown report selection '" + type + "' selected for '" + rule + "'"); } reportPlugins.put(type, candidate); } } return reportPlugins; } }
@SuppressWarnings("unchecked") private <T extends ExecutableRule> void addResult(Map<String, Result<T>> results) { if (currentResult != null) { results.put(currentResult.getRule().getId(), (Result<T>) currentResult); this.currentResult = null; } } }
@Override public <T extends ExecutableRule<?>> boolean accepts(T executableRule) { return executableRule.getExecutable() instanceof SourceExecutable && String.class.equals(executableRule.getExecutable().getType()); }
/** * Creates an instance of the select {@link GraphMLDecorator}. * * @param result The rule result. * @return The {@link GraphMLDecorator}. */ private GraphMLDecorator getGraphMLDecorator(Result<?> result) { String graphMLDecorator = result.getRule().getReport().getProperties().getProperty(GRAPHML_DECORATOR); Class<? extends GraphMLDecorator> decoratorClass; if (graphMLDecorator != null) { decoratorClass = classHelper.getType(graphMLDecorator); } else { decoratorClass = defaultDecoratorClass; } return classHelper.createInstance(decoratorClass); }
private void log(LoggingStrategy loggingStrategy, ExecutableRule rule, List<String> resultRows, String severityInfo, String type, String header) { loggingStrategy.log(header); loggingStrategy.log(type + ": " + rule.getId()); loggingStrategy.log("Severity: " + severityInfo); loggingStrategy.log("Number of rows: " + resultRows.size()); logDescription(loggingStrategy, rule); // we need lambdas... for (String row : resultRows) { loggingStrategy.log(row); } loggingStrategy.log(FOOTER); loggingStrategy.log(System.lineSeparator()); }
private String getCypher(ExecutableRule executableRule) { Executable executable = executableRule.getExecutable(); if (executable instanceof CypherExecutable) { return ((CypherExecutable) executable).getStatement(); } return null; } }
@Override public void setResult(Result<? extends ExecutableRule> result) throws ReportException { Rule rule = result.getRule(); Set<String> selectedReports = result.getRule().getReport().getSelectedTypes(); if ((selectedReports != null && selectedReports.contains(GRAPHML)) || (rule instanceof Concept && rule.getId().matches(conceptPattern))) { SubGraph subGraph = subGraphFactory.createSubGraph(result); try { String fileName = ReportHelper.escapeRuleId(rule); if (!fileName.endsWith(FILEEXTENSION_GRAPHML)) { fileName = fileName + FILEEXTENSION_GRAPHML; } File file = new File(reportDirectory, fileName); xmlGraphMLWriter.write(result, subGraph, file); reportContext.addReport("GraphML", result.getRule(), ReportContext.ReportType.LINK, file.toURI().toURL()); } catch (IOException | XMLStreamException e) { throw new ReportException("Cannot write custom report.", e); } } } }
@Override public <T extends ExecutableRule<?>> Result<T> execute(T executableRule, Map<String, Object> parameters, Severity severity, AnalyzerContext context) throws RuleException { Executable<String> executable = executableRule.getExecutable(); String cypher = executable.getSource(); return execute(cypher, executableRule, parameters, severity, context); }
@Override public <T extends ExecutableRule<?>> Result<T> execute(T executableRule, Map<String, Object> ruleParameters, Severity severity, AnalyzerContext context) throws RuleException { Executable<String> executable = executableRule.getExecutable(); String language = executable.getLanguage(); ScriptEngine scriptEngine = scriptEngineManager.getEngineByName(language);
private void writeExecutable(ExecutableRuleType executableRuleType, ExecutableRule executableRule) { Executable<?> executable = executableRule.getExecutable(); SourceType sourceType = new SourceType(); sourceType.setLanguage(executable.getLanguage()); sourceType.setValue(executable.getSource().toString()); executableRuleType.setSource(sourceType); }
@Override public <T extends ExecutableRule<?>> Result<T> execute(T executableRule, Map<String, Object> ruleParameters, Severity severity, AnalyzerContext context) throws RuleException { SourceExecutable<String> executable = (SourceExecutable<String>) executableRule.getExecutable(); String source = executable.getSource(); Constructor c = new Constructor(YamlRuleSource.class); c.setPropertyUtils(new PropertyUtils() { @Override public Property getProperty(Class<? extends Object> type, String name) { return super.getProperty(type, LOWER_HYPHEN.to(LOWER_CAMEL, name)); } }); YamlRuleSource yamlRuleSource = new Yaml(c).loadAs(source, YamlRuleSource.class); String javaRuleClass = yamlRuleSource.getJavaRule(); if (javaRuleClass == null) { throw new RuleException("'java-rule-class' is required."); } JavaRule javaRule = getJavaRule(javaRuleClass); return javaRule.execute(executableRule, yamlRuleSource.getConfiguration(), ruleParameters, severity, context); }