protected final Class<?> getInterfaceClass(DelegateExecution execution) throws Exception { if (interfaceClass == null) { return getSimpleProjectEngineFactory(execution).getInterfaceClass(); } else { return interfaceClass; } }
public SimpleProjectEngineFactory<T> build() { if (project == null || project.isEmpty()) { throw new IllegalArgumentException("project must not be null or empty!"); } File projectFile = new File(project); File workspaceFile = workspace == null ? null : new File(workspace); return new SimpleProjectEngineFactory<T>(projectFile, workspaceFile, classLoader, module, interfaceClass, externalParameters, provideRuntimeContext, provideVariations, executionMode); }
private List<ProjectDescriptor> getDependentProjects(ProjectDescriptor project, Collection<ProjectDescriptor> projectsInWorkspace) { List<ProjectDescriptor> projectDescriptors = new ArrayList<ProjectDescriptor>(); addDependentProjects(projectDescriptors, project, projectsInWorkspace); return projectDescriptors; }
protected IDependencyManager buildDependencyManager() throws ProjectResolvingException { Collection<ProjectDescriptor> projectDescriptors = new ArrayList<ProjectDescriptor>(); ProjectResolver projectResolver = ProjectResolver.instance(); ProjectDescriptor projectDescriptor = getProjectDescriptor(); if (workspace != null) { File[] files = workspace.listFiles(); List<ProjectDescriptor> projects; ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); try { if (classLoader != null) { Thread.currentThread().setContextClassLoader(classLoader); } projects = projectResolver.resolve(files); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } List<ProjectDescriptor> dependentProjects = getDependentProjects(projectDescriptor, projects); projectDescriptors.addAll(dependentProjects); } projectDescriptors.add(projectDescriptor); SimpleProjectDependencyManager dependencyManager = new SimpleProjectDependencyManager(projectDescriptors, classLoader, isSingleModuleMode(), isExecutionMode()); dependencyManager.setExternalParameters(getExternalParameters()); return dependencyManager; }
if (rulesInstantiationStrategy == null) { RulesInstantiationStrategy instantiationStrategy = null; if (!isSingleModuleMode()) { instantiationStrategy = getStrategy(getProjectDescriptor().getModules(), getDependencyManager()); } else { for (Module module : getProjectDescriptor().getModules()) { if (module.getName().equals(this.module)) { Collection<Module> modules = new ArrayList<Module>(); modules.add(module); instantiationStrategy = getStrategy(modules, getDependencyManager()); break; if (isProvideVariations()){ instantiationStrategy = new VariationInstantiationStrategyEnhancer(instantiationStrategy); if (isProvideRuntimeContext()) { instantiationStrategy = new RuntimeContextInstantiationStrategyEnhancer(instantiationStrategy); if (!isSingleModuleMode()) { parameters = ProjectExternalDependenciesHelper.getExternalParamsWithProjectDependencies(externalParameters, getProjectDescriptor().getModules());
private Summary executeAllAtOnce(String sourcePath, boolean hasDependencies) throws MalformedURLException, RulesInstantiationException, ProjectResolvingException, ClassNotFoundException { URL[] urls = toURLs(classpath); ClassLoader classLoader = null; try { classLoader = new URLClassLoader(urls, SimpleProjectEngineFactory.class.getClassLoader()); SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<?> builder = new SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<Object>(); if (hasDependencies) { builder.setWorkspace(workspaceFolder.getPath()); } SimpleProjectEngineFactory<?> factory = builder.setProject(sourcePath) .setClassLoader(classLoader) .setExecutionMode(false) .setExternalParameters(externalParameters) .build(); CompiledOpenClass openLRules = factory.getCompiledOpenClass(); return executeTests(openLRules); } finally { OpenClassUtil.releaseClassLoader(classLoader); } }
.build(); CompiledOpenClass openLRules = factory.getCompiledOpenClass(); Class<?> interfaceClass = factory.getInterfaceClass(); IOpenClass openClass = openLRules.getOpenClass(); writeInterface(interfaceClass, openClass);
public CompiledOpenClass getCompiledOpenClass() throws RulesInstantiationException, ProjectResolvingException, ClassNotFoundException { return getRulesInstantiationStrategy().compile(); }
protected synchronized final IDependencyManager getDependencyManager() throws ProjectResolvingException { if (dependencyManager == null) { dependencyManager = buildDependencyManager(); } return dependencyManager; }
if (rulesInstantiationStrategy == null) { RulesInstantiationStrategy instantiationStrategy = null; if (!isSingleModuleMode()) { instantiationStrategy = getStrategy(getProjectDescriptor().getModules(), getDependencyManager()); } else { for (Module module : getProjectDescriptor().getModules()) { if (module.getName().equals(this.module)) { Collection<Module> modules = new ArrayList<Module>(); modules.add(module); instantiationStrategy = getStrategy(modules, getDependencyManager()); break; if (isProvideVariations()){ instantiationStrategy = new VariationInstantiationStrategyEnhancer(instantiationStrategy); if (isProvideRuntimeContext()) { instantiationStrategy = new RuntimeContextInstantiationStrategyEnhancer(instantiationStrategy); if (!isSingleModuleMode()) { parameters = ProjectExternalDependenciesHelper.getExternalParamsWithProjectDependencies(externalParameters, getProjectDescriptor().getModules());
protected IDependencyManager buildDependencyManager() throws ProjectResolvingException { Collection<ProjectDescriptor> projectDescriptors = new ArrayList<ProjectDescriptor>(); ProjectResolver projectResolver = ProjectResolver.instance(); ProjectDescriptor projectDescriptor = getProjectDescriptor(); if (workspace != null) { File[] files = workspace.listFiles(); List<ProjectDescriptor> projects; ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); try { if (classLoader != null) { Thread.currentThread().setContextClassLoader(classLoader); } projects = projectResolver.resolve(files); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } List<ProjectDescriptor> dependentProjects = getDependentProjects(projectDescriptor, projects); projectDescriptors.addAll(dependentProjects); } projectDescriptors.add(projectDescriptor); SimpleProjectDependencyManager dependencyManager = new SimpleProjectDependencyManager(projectDescriptors, classLoader, isSingleModuleMode(), isExecutionMode()); dependencyManager.setExternalParameters(getExternalParameters()); return dependencyManager; }
@Override public void execute(String sourcePath, boolean hasDependencies) throws Exception { URL[] urls = toURLs(classpath); ClassLoader classLoader = null; try { classLoader = new URLClassLoader(urls, SimpleProjectEngineFactory.class.getClassLoader()); SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<?> builder = new SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<Object>(); if (hasDependencies) { builder.setWorkspace(workspaceFolder.getPath()); } SimpleProjectEngineFactory<?> factory = builder.setProject(sourcePath) .setClassLoader(classLoader) .setExecutionMode(true) .setExternalParameters(externalParameters) .build(); CompiledOpenClass openLRules = factory.getCompiledOpenClass(); IOpenClass openClass = openLRules.getOpenClass(); Collection<OpenLMessage> warnMessages = OpenLMessagesUtils.filterMessagesBySeverity(openLRules.getMessages(), Severity.WARN); info("Compilation has finished."); info("DataTypes: " + openClass.getTypes().size()); info("Methods : " + openClass.getMethods().size()); info("Warnings : " + warnMessages.size()); } finally { OpenClassUtil.releaseClassLoader(classLoader); } }
.build(); CompiledOpenClass openLRules = factory.getCompiledOpenClass(); Class<?> interfaceClass = factory.getInterfaceClass(); IOpenClass openClass = openLRules.getOpenClass(); writeInterface(interfaceClass, openClass);
public CompiledOpenClass getCompiledOpenClass() throws RulesInstantiationException, ProjectResolvingException, ClassNotFoundException { return getRulesInstantiationStrategy().compile(); }
protected synchronized final IDependencyManager getDependencyManager() throws ProjectResolvingException { if (dependencyManager == null) { dependencyManager = buildDependencyManager(); } return dependencyManager; }
private Summary executeAllAtOnce(String sourcePath, boolean hasDependencies) throws MalformedURLException, RulesInstantiationException, ProjectResolvingException, ClassNotFoundException { URL[] urls = toURLs(classpath); ClassLoader classLoader = null; try { classLoader = new URLClassLoader(urls, SimpleProjectEngineFactory.class.getClassLoader()); SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<?> builder = new SimpleProjectEngineFactory.SimpleProjectEngineFactoryBuilder<Object>(); if (hasDependencies) { builder.setWorkspace(workspaceFolder.getPath()); } SimpleProjectEngineFactory<?> factory = builder.setProject(sourcePath) .setClassLoader(classLoader) .setExecutionMode(true) .setExternalParameters(externalParameters) .build(); CompiledOpenClass openLRules; try { TestMethodNodeBinder.keepTestsInExecutionMode(); openLRules = factory.getCompiledOpenClass(); } finally { TestMethodNodeBinder.removeTestsInExecutionMode(); } return executeTests(openLRules); } finally { OpenClassUtil.releaseClassLoader(classLoader); } }
protected final Class<?> getInterfaceClass(DelegateExecution execution) throws Exception { if (interfaceClass == null) { return getSimpleProjectEngineFactory(execution).getInterfaceClass(); } else { return interfaceClass; } }
public Class<?> getInterfaceClass() throws RulesInstantiationException, ProjectResolvingException, ClassNotFoundException { if (interfaceClass != null) { return interfaceClass; } if (generatedInterfaceClass != null) { return generatedInterfaceClass; } log.info("Interface class is undefined for factory. Generated interface has been used."); generatedInterfaceClass = getRulesInstantiationStrategy().getInstanceClass(); return generatedInterfaceClass; }
private List<ProjectDescriptor> getDependentProjects(ProjectDescriptor project, Collection<ProjectDescriptor> projectsInWorkspace) { List<ProjectDescriptor> projectDescriptors = new ArrayList<ProjectDescriptor>(); addDependentProjects(projectDescriptors, project, projectsInWorkspace); return projectDescriptors; }
public SimpleProjectEngineFactory<T> build() { if (project == null || project.isEmpty()) { throw new IllegalArgumentException("project must not be null or empty!"); } File projectFile = new File(project); File workspaceFile = workspace == null ? null : new File(workspace); return new SimpleProjectEngineFactory<T>(projectFile, workspaceFile, classLoader, module, interfaceClass, externalParameters, provideRuntimeContext, provideVariations, executionMode); }