From 82c67cb966b1526cf2e4b6a07a3278462bc71b9a Mon Sep 17 00:00:00 2001 From: "marco.semiao" Date: Fri, 25 Apr 2014 17:29:30 +0200 Subject: [PATCH 1/3] bug fix with absolute uri IMPORT exemple : @import "/less/styles_variables.less"; if the source file is not present into root directory --- pom.xml | 6 +- .../java/org/lesscss/mojo/CompileMojo.java | 301 +++++++++--------- 2 files changed, 152 insertions(+), 155 deletions(-) diff --git a/pom.xml b/pom.xml index b68aca2..36266ae 100644 --- a/pom.xml +++ b/pom.xml @@ -51,7 +51,7 @@ org.lesscss lesscss - 1.3.3 + 1.5.1-SNAPSHOT org.mockito @@ -90,7 +90,7 @@ 1.5 - + diff --git a/src/main/java/org/lesscss/mojo/CompileMojo.java b/src/main/java/org/lesscss/mojo/CompileMojo.java index cc385b0..4fdb8b5 100644 --- a/src/main/java/org/lesscss/mojo/CompileMojo.java +++ b/src/main/java/org/lesscss/mojo/CompileMojo.java @@ -35,156 +35,153 @@ */ public class CompileMojo extends AbstractLessCssMojo { - /** - * The directory for compiled CSS stylesheets. - * - * @parameter expression="${lesscss.outputDirectory}" default-value="${project.build.directory}" - * @required - */ - private File outputDirectory; - - /** - * When true the LESS compiler will compress the CSS stylesheets. - * - * @parameter expression="${lesscss.compress}" default-value="false" - */ - private boolean compress; - - /** - * The character encoding the LESS compiler will use for writing the CSS stylesheets. - * - * @parameter expression="${lesscss.encoding}" default-value="${project.build.sourceEncoding}" - */ - private String encoding; - - /** - * When true forces the LESS compiler to always compile the LESS sources. By default LESS sources are only compiled when modified (including imports) or the CSS stylesheet does not exists. - * - * @parameter expression="${lesscss.force}" default-value="false" - */ - private boolean force; - - /** - * The location of the LESS JavasSript file. - * - * @parameter - */ - private File lessJs; - - /** - * The location of the NodeJS executable. - * - * @parameter - */ - private String nodeExecutable; - - /** - * Execute the MOJO. - * - * @throws MojoExecutionException - * if something unexpected occurs. - */ - public void execute() throws MojoExecutionException { - - long start = System.currentTimeMillis(); - - if (getLog().isDebugEnabled()) { - getLog().debug("sourceDirectory = " + sourceDirectory); - getLog().debug("outputDirectory = " + outputDirectory); - getLog().debug("includes = " + Arrays.toString(includes)); - getLog().debug("excludes = " + Arrays.toString(excludes)); - getLog().debug("force = " + force); - getLog().debug("lessJs = " + lessJs); - } - - String[] files = getIncludedFiles(); - - if (files == null || files.length < 1) { - getLog().info("Nothing to compile - no LESS sources found"); - } else { - if (getLog().isDebugEnabled()) { - getLog().debug("included files = " + Arrays.toString(files)); - } - - Object lessCompiler = initLessCompiler(); - try { - for (String file : files) { - File input = new File(sourceDirectory, file); - - buildContext.removeMessages(input); - - File output = new File(outputDirectory, file.replace(".less", ".css")); - - if (!output.getParentFile().exists() && !output.getParentFile().mkdirs()) { - throw new MojoExecutionException("Cannot create output directory " + output.getParentFile()); - } - - try { - LessSource lessSource = new LessSource(input); - - if (output.lastModified() < lessSource.getLastModifiedIncludingImports() || force) { - getLog().info("Compiling LESS source: " + file + "..."); - if (lessCompiler instanceof LessCompiler) { - ((LessCompiler) lessCompiler).compile(lessSource, output, force); - } else { - ((NodeJsLessCompiler) lessCompiler).compile(lessSource, output, force); - } - buildContext.refresh(output); - } - else { - getLog().info("Bypassing LESS source: " + file + " (not modified)"); - } - } catch (IOException e) { - buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); - throw new MojoExecutionException("Error while compiling LESS source: " + file, e); - } catch (LessException e) { - String message = e.getMessage(); - if (StringUtils.isEmpty(message)) { - message = "Error compiling LESS source"; - } - buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); - throw new MojoExecutionException("Error while compiling LESS source: " + file, e); - } catch (InterruptedException e) { - buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); - throw new MojoExecutionException("Error while compiling LESS source: " + file, e); - } - } - } finally { - if (lessCompiler instanceof NodeJsLessCompiler) { - ((NodeJsLessCompiler) lessCompiler).close(); - } - } - - getLog().info("Compilation finished in " + (System.currentTimeMillis() - start) + " ms"); - } - } - - private Object initLessCompiler() throws MojoExecutionException { - if (nodeExecutable != null) { - NodeJsLessCompiler lessCompiler; - try { - lessCompiler = new NodeJsLessCompiler(compress, encoding, getLog()); - } catch (IOException e) { - throw new MojoExecutionException(e.getMessage(), e); - } - if (lessJs != null) { - throw new MojoExecutionException( - "Custom LESS JavaScript is not currently supported when using nodeExecutable"); - } - return lessCompiler; - } else { - LessCompiler lessCompiler = new LessCompiler(); - lessCompiler.setCompress(compress); - lessCompiler.setEncoding(encoding); - if (lessJs != null) { - try { - lessCompiler.setLessJs(lessJs.toURI().toURL()); - } catch (MalformedURLException e) { - throw new MojoExecutionException( - "Error while loading LESS JavaScript: " + lessJs.getAbsolutePath(), e); - } - } - return lessCompiler; - } - } + /** + * The directory for compiled CSS stylesheets. + * + * @parameter expression="${lesscss.outputDirectory}" default-value="${project.build.directory}" + * @required + */ + private File outputDirectory; + + /** + * When true the LESS compiler will compress the CSS stylesheets. + * + * @parameter expression="${lesscss.compress}" default-value="false" + */ + private boolean compress; + + /** + * The character encoding the LESS compiler will use for writing the CSS stylesheets. + * + * @parameter expression="${lesscss.encoding}" default-value="${project.build.sourceEncoding}" + */ + private String encoding; + + /** + * When true forces the LESS compiler to always compile the LESS sources. By default LESS sources are + * only compiled when modified (including imports) or the CSS stylesheet does not exists. + * + * @parameter expression="${lesscss.force}" default-value="false" + */ + private boolean force; + + /** + * The location of the LESS JavasSript file. + * + * @parameter + */ + private File lessJs; + + /** + * The location of the NodeJS executable. + * + * @parameter + */ + private String nodeExecutable; + + /** + * Execute the MOJO. + * + * @throws MojoExecutionException if something unexpected occurs. + */ + public void execute() throws MojoExecutionException { + + long start = System.currentTimeMillis(); + + if (getLog().isDebugEnabled()) { + getLog().debug("sourceDirectory = " + sourceDirectory); + getLog().debug("outputDirectory = " + outputDirectory); + getLog().debug("includes = " + Arrays.toString(includes)); + getLog().debug("excludes = " + Arrays.toString(excludes)); + getLog().debug("force = " + force); + getLog().debug("lessJs = " + lessJs); + } + + String[] files = getIncludedFiles(); + + if (files == null || files.length < 1) { + getLog().info("Nothing to compile - no LESS sources found"); + } else { + if (getLog().isDebugEnabled()) { + getLog().debug("included files = " + Arrays.toString(files)); + } + + Object lessCompiler = initLessCompiler(); + try { + for (String file : files) { + File input = new File(sourceDirectory, file); + + buildContext.removeMessages(input); + + File output = new File(outputDirectory, file.replace(".less", ".css")); + + if (!output.getParentFile().exists() && !output.getParentFile().mkdirs()) { + throw new MojoExecutionException("Cannot create output directory " + output.getParentFile()); + } + + try { + LessSource lessSource = new LessSource(sourceDirectory, input); + + if (output.lastModified() < lessSource.getLastModifiedIncludingImports() || force) { + getLog().info("Compiling LESS source: " + file + "..."); + if (lessCompiler instanceof LessCompiler) { + ((LessCompiler) lessCompiler).compile(lessSource, output, force); + } else { + ((NodeJsLessCompiler) lessCompiler).compile(lessSource, output, force); + } + buildContext.refresh(output); + } else { + getLog().info("Bypassing LESS source: " + file + " (not modified)"); + } + } catch (IOException e) { + buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); + throw new MojoExecutionException("Error while compiling LESS source: " + file, e); + } catch (LessException e) { + String message = e.getMessage(); + if (StringUtils.isEmpty(message)) { + message = "Error compiling LESS source"; + } + buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); + throw new MojoExecutionException("Error while compiling LESS source: " + file, e); + } catch (InterruptedException e) { + buildContext.addMessage(input, 0, 0, "Error compiling LESS source", BuildContext.SEVERITY_ERROR, e); + throw new MojoExecutionException("Error while compiling LESS source: " + file, e); + } + } + } finally { + if (lessCompiler instanceof NodeJsLessCompiler) { + ((NodeJsLessCompiler) lessCompiler).close(); + } + } + + getLog().info("Compilation finished in " + (System.currentTimeMillis() - start) + " ms"); + } + } + + private Object initLessCompiler() throws MojoExecutionException { + if (nodeExecutable != null) { + NodeJsLessCompiler lessCompiler; + try { + lessCompiler = new NodeJsLessCompiler(compress, encoding, getLog()); + } catch (IOException e) { + throw new MojoExecutionException(e.getMessage(), e); + } + if (lessJs != null) { + throw new MojoExecutionException("Custom LESS JavaScript is not currently supported when using nodeExecutable"); + } + return lessCompiler; + } else { + LessCompiler lessCompiler = new LessCompiler(); + lessCompiler.setCompress(compress); + lessCompiler.setEncoding(encoding); + if (lessJs != null) { + try { + lessCompiler.setLessJs(lessJs.toURI().toURL()); + } catch (MalformedURLException e) { + throw new MojoExecutionException("Error while loading LESS JavaScript: " + lessJs.getAbsolutePath(), e); + } + } + return lessCompiler; + } + } } From f786f233d75dcd25471e3c66bd3b821843a9789c Mon Sep 17 00:00:00 2001 From: Marco Semiao Date: Mon, 12 May 2014 10:51:51 +0200 Subject: [PATCH 2/3] Because doesn't work in windows 8, The maven plugin doesn't use a path of nodejs command for execute. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit the "nodeExecutable" variable in maven plugin, it's used only for determine, the implementation of compilation, NodeJsLessCompiler or LessCompiler. I added a pull request for this [ERROR] C:\temp\lesscss-maven-plugin\target\it\nodejs\src\main\less\test.less [0:0]: Error compiling LESS source java.io.IOException: Cannot run program "node": CreateProcess error=2, Le fichier spécifié est introuvable at java.lang.ProcessBuilder.start(ProcessBuilder.java:1042) at org.lesscss.mojo.NodeJsLessCompiler.compile(NodeJsLessCompiler.java:134) at org.lesscss.mojo.NodeJsLessCompiler.compile(NodeJsLessCompiler.java:116) at org.lesscss.mojo.CompileMojo.execute(CompileMojo.java:130) --- pom.xml | 4 ++-- src/main/java/org/lesscss/mojo/CompileMojo.java | 4 ++-- src/main/java/org/lesscss/mojo/NodeJsLessCompiler.java | 8 +++++--- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/pom.xml b/pom.xml index 36266ae..4fc933a 100644 --- a/pom.xml +++ b/pom.xml @@ -90,7 +90,7 @@ 1.5 - + diff --git a/src/main/java/org/lesscss/mojo/CompileMojo.java b/src/main/java/org/lesscss/mojo/CompileMojo.java index 4fdb8b5..4f911f0 100644 --- a/src/main/java/org/lesscss/mojo/CompileMojo.java +++ b/src/main/java/org/lesscss/mojo/CompileMojo.java @@ -77,7 +77,7 @@ public class CompileMojo extends AbstractLessCssMojo { * * @parameter */ - private String nodeExecutable; + private File nodeExecutable; /** * Execute the MOJO. @@ -162,7 +162,7 @@ private Object initLessCompiler() throws MojoExecutionException { if (nodeExecutable != null) { NodeJsLessCompiler lessCompiler; try { - lessCompiler = new NodeJsLessCompiler(compress, encoding, getLog()); + lessCompiler = new NodeJsLessCompiler(nodeExecutable, compress, encoding, getLog()); } catch (IOException e) { throw new MojoExecutionException(e.getMessage(), e); } diff --git a/src/main/java/org/lesscss/mojo/NodeJsLessCompiler.java b/src/main/java/org/lesscss/mojo/NodeJsLessCompiler.java index 3e72317..69305be 100644 --- a/src/main/java/org/lesscss/mojo/NodeJsLessCompiler.java +++ b/src/main/java/org/lesscss/mojo/NodeJsLessCompiler.java @@ -72,8 +72,10 @@ public class NodeJsLessCompiler { private final boolean compress; private final String encoding; private final File tempDir; - - public NodeJsLessCompiler(boolean compress, String encoding, Log log) throws IOException { + private final File nodeExecutable; + + public NodeJsLessCompiler(File nodeExecutable, boolean compress, String encoding, Log log) throws IOException { + this.nodeExecutable = nodeExecutable; this.compress = compress; this.encoding = encoding; this.log = log; @@ -128,7 +130,7 @@ private String compile(String input) throws LessException, IOException, Interrup File outputFile = File.createTempFile("lessc-output-", ".css"); File lesscJsFile = new File(tempDir, "lessc.js"); - ProcessBuilder pb = new ProcessBuilder("node", lesscJsFile.getAbsolutePath(), + ProcessBuilder pb = new ProcessBuilder(nodeExecutable.getAbsolutePath(), lesscJsFile.getAbsolutePath(), inputFile.getAbsolutePath(), outputFile.getAbsolutePath(), String.valueOf(compress)); pb.redirectErrorStream(true); Process process = pb.start(); From 132bdfb22a6723d326bf76b0686d7955060fb168 Mon Sep 17 00:00:00 2001 From: Marco Semiao Date: Wed, 2 Jul 2014 17:06:17 +0200 Subject: [PATCH 3/3] correct test with new constructor LessSource (sourceDirectory) --- .../org/lesscss/mojo/CompileMojoTest.java | 581 +++++++++--------- 1 file changed, 291 insertions(+), 290 deletions(-) diff --git a/src/test/java/org/lesscss/mojo/CompileMojoTest.java b/src/test/java/org/lesscss/mojo/CompileMojoTest.java index 37118e5..e0fdbb4 100644 --- a/src/test/java/org/lesscss/mojo/CompileMojoTest.java +++ b/src/test/java/org/lesscss/mojo/CompileMojoTest.java @@ -42,7 +42,6 @@ import org.lesscss.LessCompiler; import org.lesscss.LessException; import org.lesscss.LessSource; -import org.lesscss.mojo.CompileMojo; import org.mockito.Mock; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @@ -52,428 +51,430 @@ @RunWith(PowerMockRunner.class) public class CompileMojoTest extends AbstractMojoTestCase { - private CompileMojo mojo; + private CompileMojo mojo; - private File sourceDirectory = new File("./source"); + private final File sourceDirectory = new File("./source"); - private File outputDirectory = new File("./output"); + private final File outputDirectory = new File("./output"); - private String[] includes = new String[] { "include" }; + private final String[] includes = new String[]{"include"}; - private String[] excludes = new String[] { "exclude" }; + private final String[] excludes = new String[]{"exclude"}; - private String[] files = new String[] { "file" }; + private String[] files = new String[]{"file"}; - @Mock - private Log log; + @Mock + private Log log; - @Mock - private BuildContext buildContext; + @Mock + private BuildContext buildContext; - @Mock - private Scanner scanner; + @Mock + private Scanner scanner; - @Mock - private LessCompiler lessCompiler; + @Mock + private LessCompiler lessCompiler; - @Mock - private File lessJs; + @Mock + private File lessJs; - @Mock - private URI lessJsURI; + @Mock + private URI lessJsURI; - @Mock - private URL lessJsURL; + @Mock + private URL lessJsURL; - @Mock - private File input; + @Mock + private File input; - @Mock - private File output; + @Mock + private File output; - @Mock - private File parent; + @Mock + private File parent; - @Mock - private LessSource lessSource; + @Mock + private LessSource lessSource; - @Before - public void setUp() throws URISyntaxException, IllegalAccessException, IOException { - mojo = new CompileMojo(); - mojo.setLog(log); + @Override + @Before + public void setUp() throws URISyntaxException, IllegalAccessException, IOException { + mojo = new CompileMojo(); + mojo.setLog(log); - setVariableValueToObject(mojo, "buildContext", buildContext); - setVariableValueToObject(mojo, "sourceDirectory", sourceDirectory); - setVariableValueToObject(mojo, "outputDirectory", outputDirectory); - setVariableValueToObject(mojo, "includes", includes); - setVariableValueToObject(mojo, "excludes", excludes); - } + setVariableValueToObject(mojo, "buildContext", buildContext); + setVariableValueToObject(mojo, "sourceDirectory", sourceDirectory); + setVariableValueToObject(mojo, "outputDirectory", outputDirectory); + setVariableValueToObject(mojo, "includes", includes); + setVariableValueToObject(mojo, "excludes", excludes); + } - @Test - public void testExecution() throws Exception { - files = new String[] { "less.less" }; + @Test + public void testExecution() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenReturn(lessSource); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenReturn(lessSource); - when(output.lastModified()).thenReturn(1l); - when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); + when(output.lastModified()).thenReturn(1l); + when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output).getParentFile(); - verify(parent).exists(); + verify(output).getParentFile(); + verify(parent).exists(); - verifyNew(LessSource.class).withArguments(input); + verifyNew(LessSource.class).withArguments(sourceDirectory, input); - verify(output).lastModified(); - verify(lessSource).getLastModifiedIncludingImports(); + verify(output).lastModified(); + verify(lessSource).getLastModifiedIncludingImports(); - verify(log).info("Compiling LESS source: less.less..."); - verify(lessCompiler).compile(lessSource, output, false); - } + verify(log).info("Compiling LESS source: less.less..."); + verify(lessCompiler).compile(lessSource, output, false); + } - @Test - public void testExecutionNotModified() throws Exception { - files = new String[] { "less.less" }; + @Test + public void testExecutionNotModified() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenReturn(lessSource); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenReturn(lessSource); - when(output.lastModified()).thenReturn(2l); - when(lessSource.getLastModifiedIncludingImports()).thenReturn(1l); + when(output.lastModified()).thenReturn(2l); + when(lessSource.getLastModifiedIncludingImports()).thenReturn(1l); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output).getParentFile(); - verify(parent).exists(); + verify(output).getParentFile(); + verify(parent).exists(); - verifyNew(LessSource.class).withArguments(input); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessSource.class).withArguments(sourceDirectory, input); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verify(output).lastModified(); - verify(lessSource).getLastModifiedIncludingImports(); + verify(output).lastModified(); + verify(lessSource).getLastModifiedIncludingImports(); - verify(log).info("Bypassing LESS source: less.less (not modified)"); - verifyNoMoreInteractions(lessCompiler); - } + verify(log).info("Bypassing LESS source: less.less (not modified)"); + verifyNoMoreInteractions(lessCompiler); + } - @Test - public void testExecutionIncludedFilesEmpty() throws Exception { - files = new String[] {}; + @Test + public void testExecutionIncludedFilesEmpty() throws Exception { + files = new String[]{}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - mojo.execute(); + mojo.execute(); - verify(log).info("Nothing to compile - no LESS sources found"); - } + verify(log).info("Nothing to compile - no LESS sources found"); + } - @Test - public void testExecutionIncludedFilesNull() throws Exception { - files = null; + @Test + public void testExecutionIncludedFilesNull() throws Exception { + files = null; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - mojo.execute(); + mojo.execute(); - verify(log).info("Nothing to compile - no LESS sources found"); - } + verify(log).info("Nothing to compile - no LESS sources found"); + } - @Test(expected = MojoExecutionException.class) - public void testExecutionIOExceptionWhenCreatingLessSource() throws Exception { - files = new String[] { "less.less" }; + @Test(expected = MojoExecutionException.class) + public void testExecutionIOExceptionWhenCreatingLessSource() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenThrow(new IOException()); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenThrow(new IOException()); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output).getParentFile(); - verify(parent).exists(); + verify(output).getParentFile(); + verify(parent).exists(); - verifyNew(LessSource.class).withArguments(input); - } + verifyNew(LessSource.class).withArguments(sourceDirectory, input); + } - @Test(expected = MojoExecutionException.class) - public void testExecutionLessExceptionWhenCompilingLessSource() throws Exception { - files = new String[] { "less.less" }; + @Test(expected = MojoExecutionException.class) + public void testExecutionLessExceptionWhenCompilingLessSource() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenReturn(lessSource); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenReturn(lessSource); - when(output.lastModified()).thenReturn(1l); - when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); + when(output.lastModified()).thenReturn(1l); + when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); - doThrow(new LessException(new Throwable())).when(lessCompiler).compile(lessSource, output, false); + doThrow(new LessException(new Throwable())).when(lessCompiler).compile(lessSource, output, false); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output).getParentFile(); - verify(parent).exists(); + verify(output).getParentFile(); + verify(parent).exists(); - verifyNew(LessSource.class).withArguments(input); + verifyNew(LessSource.class).withArguments(sourceDirectory, input); - verify(output).lastModified(); - verify(lessSource).getLastModifiedIncludingImports(); + verify(output).lastModified(); + verify(lessSource).getLastModifiedIncludingImports(); - verify(log).info("Compiling LESS source: less.less..."); - verify(lessCompiler).compile(lessSource, output, false); - } + verify(log).info("Compiling LESS source: less.less..."); + verify(lessCompiler).compile(lessSource, output, false); + } - @Test - public void testExecutionWithCustomLessJs() throws Exception { - setVariableValueToObject(mojo, "lessJs", lessJs); + @Test + public void testExecutionWithCustomLessJs() throws Exception { + setVariableValueToObject(mojo, "lessJs", lessJs); - files = new String[] { "less.less" }; + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - when(lessJs.toURI()).thenReturn(lessJsURI); - when(lessJsURI.toURL()).thenReturn(lessJsURL); + when(lessJs.toURI()).thenReturn(lessJsURI); + when(lessJsURI.toURL()).thenReturn(lessJsURL); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenReturn(lessSource); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenReturn(lessSource); - when(output.lastModified()).thenReturn(1l); - when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); + when(output.lastModified()).thenReturn(1l); + when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); - verify(lessCompiler).setLessJs(lessJsURL); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); + verify(lessCompiler).setLessJs(lessJsURL); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output).getParentFile(); - verify(parent).exists(); + verify(output).getParentFile(); + verify(parent).exists(); - verifyNew(LessSource.class).withArguments(input); + verifyNew(LessSource.class).withArguments(sourceDirectory, input); - verify(output).lastModified(); - verify(lessSource).getLastModifiedIncludingImports(); + verify(output).lastModified(); + verify(lessSource).getLastModifiedIncludingImports(); - verify(log).info("Compiling LESS source: less.less..."); - verify(lessCompiler).compile(lessSource, output, false); - } + verify(log).info("Compiling LESS source: less.less..."); + verify(lessCompiler).compile(lessSource, output, false); + } - @Test(expected = MojoExecutionException.class) - public void testExecutionMalformedURLExceptionWhenCustomLessJs() throws Exception { - setVariableValueToObject(mojo, "lessJs", lessJs); + @Test(expected = MojoExecutionException.class) + public void testExecutionMalformedURLExceptionWhenCustomLessJs() throws Exception { + setVariableValueToObject(mojo, "lessJs", lessJs); - files = new String[] { "less.less" }; + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - when(lessJs.toURI()).thenReturn(lessJsURI); - when(lessJsURI.toURL()).thenThrow(new MalformedURLException()); + when(lessJs.toURI()).thenReturn(lessJsURI); + when(lessJsURI.toURL()).thenThrow(new MalformedURLException()); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); - } + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); + } - @Test - public void testExecutionMakeDirsWhenOutputDirectoryDoesNotExists() throws Exception { - files = new String[] { "less.less" }; + @Test + public void testExecutionMakeDirsWhenOutputDirectoryDoesNotExists() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(false); - when(parent.mkdirs()).thenReturn(true); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(false); + when(parent.mkdirs()).thenReturn(true); - whenNew(LessSource.class).withArguments(input).thenReturn(lessSource); + whenNew(LessSource.class).withArguments(sourceDirectory, input).thenReturn(lessSource); - when(output.lastModified()).thenReturn(1l); - when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); + when(output.lastModified()).thenReturn(1l); + when(lessSource.getLastModifiedIncludingImports()).thenReturn(2l); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output, times(2)).getParentFile(); - verify(parent).exists(); - verify(parent).mkdirs(); + verify(output, times(2)).getParentFile(); + verify(parent).exists(); + verify(parent).mkdirs(); - verifyNew(LessSource.class).withArguments(input); + verifyNew(LessSource.class).withArguments(sourceDirectory, input); - verify(output).lastModified(); - verify(lessSource).getLastModifiedIncludingImports(); + verify(output).lastModified(); + verify(lessSource).getLastModifiedIncludingImports(); - verify(log).info("Compiling LESS source: less.less..."); - verify(lessCompiler).compile(lessSource, output, false); - } + verify(log).info("Compiling LESS source: less.less..."); + verify(lessCompiler).compile(lessSource, output, false); + } - @Test(expected = MojoExecutionException.class) - public void testExecutionMakeDirsFailsWhenOutputDirectoryDoesNotExists() throws Exception { - files = new String[] { "less.less" }; + @Test(expected = MojoExecutionException.class) + public void testExecutionMakeDirsFailsWhenOutputDirectoryDoesNotExists() throws Exception { + files = new String[]{"less.less"}; - when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); - when(scanner.getIncludedFiles()).thenReturn(files); + when(buildContext.newScanner(sourceDirectory, true)).thenReturn(scanner); + when(scanner.getIncludedFiles()).thenReturn(files); - whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); + whenNew(LessCompiler.class).withNoArguments().thenReturn(lessCompiler); - whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); - whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); + whenNew(File.class).withArguments(sourceDirectory, "less.less").thenReturn(input); + whenNew(File.class).withArguments(outputDirectory, "less.css").thenReturn(output); - when(output.getParentFile()).thenReturn(parent); - when(parent.exists()).thenReturn(false); - when(parent.mkdirs()).thenReturn(false); + when(output.getParentFile()).thenReturn(parent); + when(parent.exists()).thenReturn(false); + when(parent.mkdirs()).thenReturn(false); - mojo.execute(); + mojo.execute(); - verify(buildContext).newScanner(same(sourceDirectory), eq(true)); - verify(scanner).setIncludes(same(includes)); - verify(scanner).setExcludes(same(excludes)); - verify(scanner).scan(); + verify(buildContext).newScanner(same(sourceDirectory), eq(true)); + verify(scanner).setIncludes(same(includes)); + verify(scanner).setExcludes(same(excludes)); + verify(scanner).scan(); - verifyNew(LessCompiler.class).withNoArguments(); - verify(lessCompiler).setCompress(false); - verify(lessCompiler).setEncoding(null); + verifyNew(LessCompiler.class).withNoArguments(); + verify(lessCompiler).setCompress(false); + verify(lessCompiler).setEncoding(null); - verifyNew(File.class).withArguments(sourceDirectory, "less.less"); - verifyNew(File.class).withArguments(outputDirectory, "less.css"); + verifyNew(File.class).withArguments(sourceDirectory, "less.less"); + verifyNew(File.class).withArguments(outputDirectory, "less.css"); - verify(output, times(2)).getParentFile(); - verify(parent).exists(); - verify(parent).mkdirs(); - } + verify(output, times(2)).getParentFile(); + verify(parent).exists(); + verify(parent).mkdirs(); + } - @After - public void tearDown() { - } + @Override + @After + public void tearDown() { + } }