Revert "Merge pull request #6 from MartinFiorde/refactor/clean-personal-practice"

This reverts commit 2430990, reversing
changes made to b768f15.

Author: MartinFiorde

docs/Apuntes java functional.docx

@@ -8,6 +8,20 @@
 import java.util.function.Supplier;
 
 public interface CommanderFunctions {
+    /**
+     * JCommander permite generar opciones de terminal de cualquier clase, por eso el primer parametro es
+     * de tipo Object.
+     *
+     * @param object Clase de la cual se generaran los argumentos de JCommander
+     * @return una instancia de JCommander. Idealmente con CLIArguments como objeto pasado.
+     */
+    static JCommander buildCommander(Object object) {
+        return JCommander
+                .newBuilder()
+                .addObject(object)
+                .build();
+    }
+
     /**
      * Con esta funcion, facilitamos crear una configuracion inicial de JCommander, pidiendo el nombre del
      * programa y un Supplier de tipo T para los argumentos. Asi podemos usar alguna funcion que nos devuelva
@@ -19,11 +33,7 @@ public interface CommanderFunctions {
      * @return una instancia de {@link JCommander} ya configurada con el nombre y los argumentos.
      */
     static <T> JCommander buildCommanderWithName(String name, Supplier<T> argumentsSupplier) {
-        // JCommander permite generar opciones de terminal de cualquier clase, por eso se le agrega un object con el metodo addObject(...)
-        // argumentsSupplier.get() es la clase de la cual se generaran los argumentos de JCommander
-        // Queda definida una instancia de JCommander. Idealmente con CLIArguments como objeto pasado.
-        JCommander jCommander = JCommander.newBuilder().addObject(argumentsSupplier.get()).build();
-
+        JCommander jCommander = buildCommander(argumentsSupplier.get());
         jCommander.setProgramName(name);
         return jCommander;
     }
@@ -35,14 +45,18 @@ static <T> JCommander buildCommanderWithName(String name, Supplier<T> argumentsS
     static Optional<List<Object>> parseArguments(
             JCommander jCommander,
             String[] arguments,
-            OnCommandError onCommandError) { // en caso que las validaciones de CLIKeywordValidaror o CLIHelpValidator fallen, se generará un ParameterException
+            OnCommandError onCommandError
+    ) {
+        List<Object> result;
         try {
             jCommander.parse(arguments);
+
             return Optional.of(jCommander.getObjects());
-        } catch (ParameterException exception) { // atrapará el parameter exception y devuelve un optional vacio
+        } catch (ParameterException exception) {
             onCommandError.onError(jCommander);
-            return Optional.empty();
         }
+
+        return Optional.empty();
     }
 
     @FunctionalInterface

docs/Functional SE.pdf

@@ -21,22 +21,31 @@ public static void main(String[] args) {
         JCommander jCommander = buildCommanderWithName("job-search", CLIArguments::newInstance);
 
         //Obtenemos las opciones que se le dieron a JCommander
-        Stream<CLIArguments> streamOfCLI = parseArguments(jCommander, args, JCommander::usage) //Nos retorna un Optional<List<Object>>
-                        .orElse(Collections.emptyList()) //En caso de un Optional.empty()
+        Stream<CLIArguments> streamOfCLI =
+                //Nos retorna un Optional<List<Object>>
+                parseArguments(jCommander, args, JCommander::usage)
+                        //En caso de un Optional.empty()
+                        .orElse(Collections.emptyList())
                         .stream()
                         .map(CLIArguments.class::cast); // map(obj -> (CLIArguments) obj) give same result
 
         //Tomamos nuestro Stream y obtenemos las opciones que se dieron en el CLI
         Optional<CLIArguments> cliOptional = streamOfCLI
-                .filter(cli -> !cli.isHelp()) //Solo nos interesan los casos donde no sea la solicitud de ayuda
-                .filter(cli -> cli.getKeyword() != null) //Y que contengan un keyword, en otros caso no tenemos que buscar
+                //Solo nos interesan los casos donde no sea la solicitud de ayuda
+                .filter(cli -> !cli.isHelp())
+                //Y que contengan un keyword, en otros caso no tenemos que buscar
+                .filter(cli -> cli.getKeyword() != null)
                 .findFirst();
 
         //Si el Optional tiene un dato, lo convertimos a Map<String,Object>
         cliOptional.map(CLIFunctions::toMap)
-                .map(JobSearch::executeRequest) //Convertimos el Map en un request
-                .orElse(Stream.empty()) //Aun seguimos operando sobre un Optional… en caso de que no hubiera datos generamos un stream vacio
-                .forEach(System.out::println); //Imprimos los datos por pantalla.
+                //Convertimos el Map en un request
+                .map(JobSearch::executeRequest)
+                //Aun seguimos operando sobre un Optional… en caso de que no hubiera datos
+                //Generamos un stream vacio
+                .orElse(Stream.empty())
+                //Imprimos los datos por pantalla.
+                .forEach(System.out::println);
     }
 
     private static Stream<JobPosition> executeRequest(Map<String, Object> options) {

docs/java 8 streams cheatsheet.webp

@@ -44,7 +44,7 @@ public final class CLIArguments {
     private boolean isMarkdown = false;
 
     @Parameter(
-            names = {"--help", "-h"},
+            names = "--help",
             help = true,
             validateWith = CLIHelpValidator.class,
             description = "Muestra esta ayuda")

jobs-search-reporter/src/main/java/com/platzi/jobsearch/CommanderFunctions.java

@@ -11,7 +11,7 @@
 public class CLIKeywordValidator implements IParameterValidator {
     @Override
     public void validate(String name, String value) throws ParameterException {
-        if (!value.matches("^[a-zA-Z]+\\d*$")) {
+        if (!value.matches("^[a-zA-Z]+[0-9]*$")) {
             System.err.println("Keyword: " + value + " no es un Keyword valido, keywords deben ser alfanumericas.\n");
             throw new ParameterException("Only alphanumerics are supported");
         }

jobs-search-reporter/src/main/java/com/platzi/jobsearch/JobSearch.java

@@ -1,4 +1,66 @@
 package com.platzi.functional_student_practice._03_inmutable;
 
+import java.util.List;
+
 public class C8InmutObjWithMutAttributes {
+
+    public static void main(String[] args) {
+
+        System.out.println("////////////////////////////////////////////////////////////////////////////////////");
+        System.out.println("\nCLASS 8\n");
+
+        // 1. We make an inmutable object (without setters)
+        Direccion dir = new Direccion("New York");
+
+        // 2. We make a mutable object (with setters)
+        Persona p1 = new Persona(dir);
+
+        // 3. We make an inmutable list
+        List<Persona> lista1 = List.of(p1);
+
+        // 4. Try to change mutable element from inmutable list is allowed
+        System.out.println("Antes de modificar: " + lista1);
+        p1.getDireccion().setCiudad("Los Angeles");
+        System.out.println("Después de modificar: " + lista1);
+
+    }
+
+    private static class Direccion {
+        String ciudad;
+
+        Direccion(String ciudad) {
+            this.ciudad = ciudad;
+        }
+
+        String getCiudad() {
+            return ciudad;
+        }
+
+        void setCiudad(String ciudad) {
+            this.ciudad = ciudad;
+        }
+
+        @Override
+        public String toString() {
+            return ciudad;
+        }
+    }
+
+    private static class Persona {
+        private final Direccion direccion;
+
+        Persona(Direccion direccion) {
+            this.direccion = direccion;
+        }
+
+        public Direccion getDireccion() {
+            return direccion;
+        }
+
+        @Override
+        public String toString() {
+            return "Persona{direccion=" + direccion + "}";
+        }
+    }
+
 }

jobs-search-reporter/src/main/java/com/platzi/jobsearch/cli/CLIArguments.java

@@ -1,4 +1,74 @@
 package com.platzi.functional_student_practice._04_functional;
 
+import java.util.function.IntPredicate;
+import java.util.function.IntUnaryOperator;
+import java.util.function.Predicate;
+
 public class C11y12MathFunctions {
+    public static void main(String[] args) {
+
+        System.out.println("////////////////////////////////////////////////////////////////////////////////////");
+        System.out.println("\nCLASS 11\n");
+
+        // 1. function as type
+//        Function<Integer, Integer> square1 = new Function<Integer, Integer>() {
+//            @Override
+//            public Integer apply(Integer x) {
+//                return x * x;
+//            }
+//        };
+//        System.out.println(square1.apply(5)+"\n");
+
+        // 2. function 1 writen in a more performant way
+        IntUnaryOperator square2 = x -> x * x;
+        System.out.println(square2.applyAsInt(6)+"\n");
+
+        // 3. function 3 declared in the class, outside the main method
+        System.out.println(square3(7));
+        System.out.println(square3(8)+"\n");
+
+
+        System.out.println("////////////////////////////////////////////////////////////////////////////////////");
+        System.out.println("\nCLASS 12\n");
+
+        // 1. Function as type using lambda to declare operation in one line
+//        Function<Integer, Boolean> isOdd1 = x -> x % 2 == 1;
+//        System.out.println(isOdd1.apply(7));
+//        System.out.println(isOdd1.apply(8)+"\n");
+
+        // 2. function 1 writen in a more performant way
+        IntPredicate isOdd2 = x -> x % 2 == 1;
+        System.out.println(isOdd2.test(7));
+        System.out.println(isOdd2.test(8)+"\n");
+
+        // 3. function Predicate by teacher
+//        Predicate<Integer> isEven1 = x -> x % 2 == 0;
+//        System.out.println(isEven1.test(7));
+//        System.out.println(isEven1.test(8)+"\n");
+
+        // 4. function 3 performant
+        IntPredicate isEven2 = x -> x % 2 == 0;
+        System.out.println(isEven2.test(7));
+        System.out.println(isEven2.test(8)+"\n");
+
+        // 5. Student example
+        Predicate<Student> isApproved = student -> student.getQualification()>= 7;
+        System.out.println(isApproved.test(new Student(6)));
+        System.out.println(isApproved.test(new Student(7)));
+    }
+
+    private static int square3(int x) {
+        return x * x;
+    }
+
+    private static class Student {
+        private final double qualification;
+        public Student(double qualification) {
+            this.qualification = qualification;
+        }
+        public double getQualification() {
+            return qualification;
+        }
+    }
+
 }

jobs-search-reporter/src/main/java/com/platzi/jobsearch/cli/CLIKeywordValidator.java

@@ -1,4 +1,57 @@
 package com.platzi.functional_student_practice._04_functional;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
 public class C13CLIUtils {
+
+    public static void main(String[] args) {
+
+        System.out.println("////////////////////////////////////////////////////////////////////////////////////\n");
+        System.out.println("CLASS 13\n");
+
+        // 1. Created CLI class, consumer and supplier
+        List<CLIArguments> list = new ArrayList<>();
+        for (int i = 0; i < 5; i++) {
+            list.add(generateCLI());
+            list.get(i).setHelp(i % 2 == 0);
+        }
+
+        for (int i = 0; i < list.size(); i++) {
+            showHelp(list.get(i), i);
+        }
+
+    }
+
+
+    private static void showHelp(CLIArguments cliArguments, int i) {
+        Consumer<CLIArguments> consumerHelper = cliArguments1 -> {
+            if (cliArguments1.isHelp()) {
+                System.out.println(i +": Manual required");
+            }
+        };
+        consumerHelper.accept(cliArguments);
+    }
+
+
+    private static CLIArguments generateCLI() {
+        Supplier<CLIArguments> generator = CLIArguments::new; //same as () -> new CLIArguments()
+        return generator.get();
+    }
+
+
+    private static class CLIArguments {
+        private boolean isHelp;
+
+        public boolean isHelp() {
+            return isHelp;
+        }
+
+        public void setHelp(boolean help) {
+            isHelp = help;
+        }
+    }
+
 }