Decoupling core built-in listeners

Author: alekseysotnikov

README.md

@@ -42,7 +42,8 @@ new Cmd().command("echo", "Hello").execute();
 ````java
 new Cmd()
        .interpreter("sh") // specify command interpreter
-       .command("-c", "s='Hello'; echo $s;").execute();
+       .command("-c", "s='Hello'; echo $s;")
+       .execute();
 ````
 or even shorter
 ````java
@@ -52,29 +53,33 @@ new Cmd().command("sh", "-c", "s='Hello'; echo $s;").execute();
 ````java
 String output = new Cmd()
                      .configuring(c -> c.readOutput(true)) // configure zt-exec's executor
-                     .interpreter("sh")
-                     .command("-c", "s='Hello'; echo $s;").execute()
+                     .command("sh", "-c", "s='Hello'; echo $s;")
+                     .execute()
                      .outputUTF8();
 System.out.println(output);
 
 // output> Hello
 ````
-> Save output stream into a file, even if the process stopped unexpectedly
+> Save an output stream into a file, even if the process stopped unexpectedly
 ```java
 new Cmd()
-      .outputFileName("output.txt")
-      .command("echo", "Hello").execute();
+      .configuring(new RedirectToFile("./output.txt"))
+      .command("echo", "Hello")
+      .execute();
 ````
->  Execute command inside a separate work directory. It creates work directory before start and delete after finish
+>  Execute command within custom work directory
 ````java
 new Cmd()
-        .configuring(c -> c.directory(new File("./", "foo"))) // specify work directory ./foo
-        .cleanUp(true) // delete work directory after process stopped, only if the directory will be created during the execution
+        .configuring(
+                new WorkDir("./foo"), // specify work directory ./foo (will be created automatically)
+                new CleanUp() // delete work directory after process stop, only if the Cmd has created the directory
+        ) 
         .listening().afterStop(process -> {
-            //work directory ./foo will be exist here
+            System.out.println(new File("./foo").exists()); //true
         }).back()
-        .command("echo", "hello world").execute(); // work directory ./foo will be created automatically
-//work directory ./foo was deleted after execution
+        .command("echo", "hello world").execute();
+
+System.out.println(new File("./foo").exists()); // false
 ````
 > Run command in a background
 ````java

pom.xml

@@ -4,7 +4,7 @@
     <groupId>com.enot</groupId>
     <artifactId>CmdTool</artifactId>
     <packaging>jar</packaging>
-    <version>0.3.2</version>
+    <version>0.4.0</version>
     <name>CmdTool</name>
     <url>http://maven.apache.org</url>
 

src/main/java/com/enot/cmd/core/Cmd.java

@@ -1,66 +1,41 @@
 package com.enot.cmd.core;
 
-import org.apache.commons.io.FileUtils;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterFinish;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterStart;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterStop;
+import com.enot.cmd.core.LambdaListenerAdapter.BeforeStart;
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.iterable.Joined;
 import org.cactoos.iterable.Mapped;
 import org.zeroturnaround.exec.ProcessExecutor;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.UncheckedIOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * Command line representation with the additional features around a process execution
  */
 public final class Cmd implements ICmd {
-    private final boolean cleanUp;
-    private final String outputFileName;
     private final Listening listening;
-    private final LambdaListenerAdapter.BeforeStart configuring;
+    private final BeforeStart[] beforeStart;
     private final String interpreter;
 
     public Cmd() {
-        this(false,
-                "",
-                new Listening(null, new IterableOf<>()),
-                e -> {
-                },
-                "");
+        this(new Listening(null, new IterableOf<>()), new BeforeStart[0], "");
     }
 
-    public Cmd(boolean cleanUp, String outputFileName, Listening listening, LambdaListenerAdapter.BeforeStart configuring, String interpreter) {
-        this.cleanUp = cleanUp;
-        this.outputFileName = outputFileName;
+    public Cmd(Listening listening, BeforeStart[] beforeStart, String interpreter) {
         this.listening = listening;
-        this.configuring = configuring;
+        this.beforeStart = beforeStart;
         this.interpreter = interpreter;
     }
 
-    /**
-     * Delete work directory after process stopped, only if the directory will be created during the execution
-     *
-     * @param cleanUp
-     * @return
-     */
     @Override
-    public Cmd cleanUp(boolean cleanUp) {
-        return new Cmd(cleanUp, outputFileName, listening, configuring, interpreter);
-    }
-
-    @Override
-    public Cmd outputFileName(String outputFileName) {
-        return new Cmd(cleanUp, outputFileName, listening, configuring, interpreter);
-    }
-
-    @Override
-    public Cmd configuring(LambdaListenerAdapter.BeforeStart configuring) {
-        return new Cmd(cleanUp, outputFileName, listening, configuring, interpreter);
+    public Cmd configuring(BeforeStart... configuring) {
+        return new Cmd(listening, configuring, interpreter);
     }
 
     @Override
@@ -70,7 +45,7 @@ public CmdListening listening() {
 
     @Override
     public Cmd interpreter(String interpreter) {
-        return new Cmd(cleanUp, outputFileName, listening, configuring, interpreter);
+        return new Cmd(listening, beforeStart, interpreter);
     }
 
     public Command command(String... command) {
@@ -79,77 +54,51 @@ public Command command(String... command) {
 
     private ProcessExecutor processExecutor(String... command) {
         ProcessExecutor executor = new ProcessExecutor();
-        configuring.run(executor);
-        for (LambdaListenerAdapter listener : listening.listeners) {
-            executor.addListener(listener);
-        }
+
+        Map<Boolean, List<BeforeStart>> configuring = Arrays.stream(beforeStart).collect(
+                Collectors.groupingBy(c -> c instanceof AfterStop));
+        List<BeforeStart> configuringBefore = configuring.getOrDefault(false, Collections.emptyList());
+        List<BeforeStart> configuringAfter = configuring.getOrDefault(true, Collections.emptyList());
+
+        configuringBefore.forEach(c -> c.run(executor));
+        listening.listeners.forEach(executor::addListener);
+        configuringAfter.forEach(c -> c.run(executor));
 
         Iterable<String> commands = new IterableOf<>(command);
         if (interpreter != null && !interpreter.trim().isEmpty()) {
             commands = new Joined<>(new IterableOf<>(interpreter), commands);
         }
-
-        LambdaListenerAdapter beforeStart = new LambdaListenerAdapter((LambdaListenerAdapter.BeforeStart) processExecutor -> {
-            File dir = processExecutor.getDirectory();
-            if (dir != null && !dir.exists()) {
-                final boolean workDirCreated = dir.mkdirs();
-                if (!workDirCreated)
-                    throw new UncheckedIOException(
-                            new IOException(String.format("Work directory %s can not be created", dir.toPath())));
-                if (cleanUp) {
-                    processExecutor.addListener(new LambdaListenerAdapter((LambdaListenerAdapter.AfterStop) p -> {
-                        try {
-                            FileUtils.deleteDirectory(dir);
-                        } catch (IOException e) {
-                            throw new UncheckedIOException(
-                                    String.format("Work directory %s can not be deleted", dir.toPath()),
-                                    e);
-                        }
-                    }));
-                }
-            }
-            if (outputFileName != null && outputFileName.length() > 0) {
-                OutputStream outputStream = createFileOS(dir);
-                processExecutor.redirectOutputAlsoTo(outputStream);
-                processExecutor.addListener(new LambdaListenerAdapter((LambdaListenerAdapter.AfterStop) process -> {
-                    try {
-                        outputStream.close();
-                    } catch (IOException e) {
-                        throw new UncheckedIOException(e);
-                    }
-                }));
-            }
-        });
-        return executor.command(commands).addListener(beforeStart);
+        return executor.command(commands);
     }
 
-    private OutputStream createFileOS(File workDir) {
-        Path outputFile;
-        if (workDir != null) {
-            outputFile = Paths.get(workDir.getPath(), outputFileName);
-        } else {
-            outputFile = Paths.get(outputFileName);
-        }
-        try {
-            return Files.newOutputStream(outputFile, StandardOpenOption.CREATE);
-        } catch (IOException e) {
-            throw new UncheckedIOException(
-                    String.format("Output file %s can not be created", outputFile),
-                    e);
-        }
-    }
 
     private static final class Listening implements CmdListening {
         private final Cmd owner;
         private final Iterable<LambdaListenerAdapter> listeners;
 
+        public Listening(Cmd owner, BeforeStart... lambdas) {
+            this(owner, new Mapped<>(LambdaListenerAdapter::new, new IterableOf<>(lambdas)));
+        }
+
+        public Listening(Cmd owner, AfterStart... lambdas) {
+            this(owner, new Mapped<>(LambdaListenerAdapter::new, new IterableOf<>(lambdas)));
+        }
+
+        public Listening(Cmd owner, AfterFinish... lambdas) {
+            this(owner, new Mapped<>(LambdaListenerAdapter::new, new IterableOf<>(lambdas)));
+        }
+
+        public Listening(Cmd owner, AfterStop... lambdas) {
+            this(owner, new Mapped<>(LambdaListenerAdapter::new, new IterableOf<>(lambdas)));
+        }
+
         public Listening(Cmd owner, Iterable<LambdaListenerAdapter> listeners) {
             this.owner = owner;
             this.listeners = listeners;
         }
 
         @Override
-        public CmdListening beforeStart(LambdaListenerAdapter.BeforeStart... lambdas) {
+        public CmdListening beforeStart(BeforeStart... lambdas) {
             return new Listening(
                     owner,
                     new Joined<>(
@@ -159,7 +108,7 @@ public CmdListening beforeStart(LambdaListenerAdapter.BeforeStart... lambdas) {
         }
 
         @Override
-        public CmdListening afterStart(LambdaListenerAdapter.AfterStart... lambdas) {
+        public CmdListening afterStart(AfterStart... lambdas) {
             return new Listening(
                     owner,
                     new Joined<>(
@@ -169,7 +118,7 @@ public CmdListening afterStart(LambdaListenerAdapter.AfterStart... lambdas) {
         }
 
         @Override
-        public CmdListening afterFinish(LambdaListenerAdapter.AfterFinish... lambdas) {
+        public CmdListening afterFinish(AfterFinish... lambdas) {
             return new Listening(
                     owner,
                     new Joined<>(
@@ -179,7 +128,7 @@ public CmdListening afterFinish(LambdaListenerAdapter.AfterFinish... lambdas) {
         }
 
         @Override
-        public CmdListening afterStop(LambdaListenerAdapter.AfterStop... lambdas) {
+        public CmdListening afterStop(AfterStop... lambdas) {
             return new Listening(
                     owner,
                     new Joined<>(
@@ -190,7 +139,7 @@ public CmdListening afterStop(LambdaListenerAdapter.AfterStop... lambdas) {
 
         @Override
         public Cmd back() {
-            return new Cmd(owner.cleanUp, owner.outputFileName, this, owner.configuring, owner.interpreter);
+            return new Cmd(this, owner.beforeStart, owner.interpreter);
         }
     }
 }

src/main/java/com/enot/cmd/core/CmdListening.java

@@ -1,13 +1,18 @@
 package com.enot.cmd.core;
 
+import com.enot.cmd.core.LambdaListenerAdapter.AfterFinish;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterStart;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterStop;
+import com.enot.cmd.core.LambdaListenerAdapter.BeforeStart;
+
 public interface CmdListening {
-    CmdListening beforeStart(LambdaListenerAdapter.BeforeStart... lambdas);
+    CmdListening beforeStart(BeforeStart... lambdas);
 
-    CmdListening afterStart(LambdaListenerAdapter.AfterStart... lambdas);
+    CmdListening afterStart(AfterStart... lambdas);
 
-    CmdListening afterFinish(LambdaListenerAdapter.AfterFinish... lambdas);
+    CmdListening afterFinish(AfterFinish... lambdas);
 
-    CmdListening afterStop(LambdaListenerAdapter.AfterStop... lambdas);
+    CmdListening afterStop(AfterStop... lambdas);
 
     Cmd back();
 }

src/main/java/com/enot/cmd/core/ICmd.java

@@ -1,11 +1,9 @@
 package com.enot.cmd.core;
 
-public interface ICmd {
-    ICmd cleanUp(boolean cleanUp);
-
-    ICmd outputFileName(String outputFileName);
+import com.enot.cmd.core.LambdaListenerAdapter.BeforeStart;
 
-    ICmd configuring(LambdaListenerAdapter.BeforeStart configuring);
+public interface ICmd {
+    ICmd configuring(BeforeStart... configuring);
 
     CmdListening listening();
 

src/main/java/com/enot/cmd/listeners/CleanUp.java

@@ -0,0 +1,33 @@
+package com.enot.cmd.listeners;
+
+import com.enot.cmd.core.LambdaListenerAdapter;
+import com.enot.cmd.core.LambdaListenerAdapter.AfterStop;
+import com.enot.cmd.core.LambdaListenerAdapter.BeforeStart;
+import org.apache.commons.io.FileUtils;
+import org.zeroturnaround.exec.ProcessExecutor;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+/**
+ * Deletes work directory after process stopped
+ */
+public final class CleanUp implements BeforeStart, AfterStop {
+    private File dir;
+
+    @Override
+    public void run(ProcessExecutor processExecutor) {
+        dir = processExecutor.getDirectory();
+        processExecutor.addListener(new LambdaListenerAdapter((AfterStop) this));
+    }
+
+    @Override
+    public void run(Process process) {
+        try {
+            FileUtils.deleteDirectory(dir);
+        } catch (IOException e) {
+            throw new UncheckedIOException("Work directory " + dir.toPath() + " can not be deleted", e);
+        }
+    }
+}