embulk 0.8.27-java → 0.8.28-java

data/embulk-cli/src/main/java/org/embulk/cli/EmbulkSelfUpdate.java

@@ -26,12 +26,11 @@ public class EmbulkSelfUpdate
     // TODO(dmikurube): Stop catching Exceptions here when embulk_run.rb is replaced to Java.
     public void updateSelf(final String runningVersionString,
                            final String specifiedVersionString,
-                           final String embulkRunRubyPathString,
                            final boolean isForced)
             throws IOException, URISyntaxException
     {
         try {
-            updateSelfWithExceptions(runningVersionString, specifiedVersionString, embulkRunRubyPathString, isForced);
+            updateSelfWithExceptions(runningVersionString, specifiedVersionString, isForced);
         }
         catch (Throwable ex) {
             ex.printStackTrace();
@@ -41,7 +40,6 @@ public class EmbulkSelfUpdate
 
     private void updateSelfWithExceptions(final String runningVersionString,
                                           final String specifiedVersionString,
-                                          final String embulkRunRubyPathString,
                                           final boolean isForced)
             throws IOException, URISyntaxException
     {
@@ -52,17 +50,6 @@ public class EmbulkSelfUpdate
             throw exceptionNoSingleJar();
         }
 
-        if (embulkRunRubyPathString != null) {
-            final String[] splitRubyFile = embulkRunRubyPathString.split("!", 2);
-            if (splitRubyFile.length < 2) {
-                throw exceptionNoSingleJar();
-            }
-            final Path jarPathRuby = Paths.get(splitRubyFile[0]);
-            if (!jarPathJava.equals(jarPathRuby)) {
-                throw exceptionNoSingleJar();
-            }
-        }
-
         final String targetVersionString;
         if (specifiedVersionString != null) {
             System.out.printf("Checking version %s...\n", specifiedVersionString);

data/embulk-cli/src/main/java/org/embulk/cli/EmbulkSubcommand.java

@@ -0,0 +1,47 @@
+package org.embulk.cli;
+
+public enum EmbulkSubcommand
+{
+    BUNDLE("bundle"),
+    CLEANUP("cleanup"),
+    EXAMPLE("example"),
+    EXEC("exec"),
+    GEM("gem"),
+    GUESS("guess"),
+    IRB("irb"),
+    MIGRATE("migrate"),
+    MKBUNDLE("mkbundle"),
+    NEW("new"),
+    PREVIEW("preview"),
+    RUN("run"),
+    SELFUPDATE("selfupdate"),
+    VERSION_OUT("--version"),
+    VERSION_ERR("-version"),
+    ;
+
+    private EmbulkSubcommand(final String subcommand)
+    {
+        this.subcommand = subcommand;
+    }
+
+    public static EmbulkSubcommand of(final String subcommand)
+            throws EmbulkCommandLineException
+    {
+        if (!(subcommand.equals("--version")) && !(subcommand.equals("-version"))) {
+            for (final EmbulkSubcommand constant : values()) {
+                if (constant.toString().equals(subcommand)) {
+                    return constant;
+                }
+            }
+        }
+        throw new EmbulkCommandLineException("Unknown subcommand " + subcommand + ".");
+    }
+
+    @Override
+    public final String toString()
+    {
+        return this.subcommand;
+    }
+
+    private final String subcommand;
+}

data/embulk-cli/src/main/java/org/embulk/cli/Main.java

@@ -1,37 +1,28 @@
 package org.embulk.cli;
 
-import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collections;
 
 public class Main
 {
-    public static void main(String[] args)
+    public static void main(final String[] args)
     {
-        // $ java -jar jruby-complete.jar embulk-core.jar!/embulk/command/embulk_bundle.rb "$@"
-        String[] jrubyArgs = new String[args.length + 1];
+        final ArrayList<String> jrubyOptions = new ArrayList<String>();
+
         int i;
-        for (i = 0; i < args.length; i++) {
+        for (i = 0; i < args.length; ++i) {
             if (args[i].startsWith("-R")) {
-                jrubyArgs[i] = args[i].substring(2);
+                jrubyOptions.add(args[i].substring(2));
             } else {
                 break;
             }
         }
-        jrubyArgs[i] = getScriptPath();
-        for (; i < args.length; i++) {
-            jrubyArgs[i+1] = args[i];
-        }
-        org.jruby.Main.main(jrubyArgs);
-    }
 
-    private static String getScriptPath()
-    {
-        String resourcePath;
-        try {
-            resourcePath = Main.class.getProtectionDomain().getCodeSource().getLocation().toURI().toString() + "!/";
-        }
-        catch (URISyntaxException ex) {
-            resourcePath = "uri:classloader:/";
+        final String[] embulkArgs = new String[args.length - i];
+        for (int j = 0; i < args.length; ++i, ++j) {
+            embulkArgs[j] = args[i];
         }
-        return resourcePath + "embulk/command/embulk_bundle.rb";
+
+        EmbulkBundle.checkBundle(embulkArgs, Collections.unmodifiableList(jrubyOptions));
     }
 }

data/embulk-cli/src/main/java/org/embulk/cli/parse/AbstractHelpLineDefinition.java

@@ -0,0 +1,15 @@
+package org.embulk.cli.parse;
+
+import org.apache.commons.cli.Option;
+
+/**
+ * AbstractHelpLineDefinition represents any one line in help messages in the command line parser.
+ *
+ * It is visible only in {@code org.embulk.cli.parse} because its interface communicates commons-cli objects.
+ * Dependencies on third-party libraries are to be encapsulated.
+ */
+abstract class AbstractHelpLineDefinition
+{
+    // Visible only in org.embulk.cli.parse to keep commons-cli segregated from other components.
+    abstract Option getCliOption();
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/CliHelpFormatterWithHelpMessages.java

@@ -0,0 +1,141 @@
+package org.embulk.cli.parse;
+
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.List;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+
+/**
+ * CliHelpFormatterWithHelpMessages is an extension of commons-cli's org.apache.commons.cli.HelpFormatter.
+ *
+ * It recognizes {@code HelpMessageAsCliOption} from {@code CliOptionsWithHelpMessages} in addition to that
+ * {@code org.apache.commons.cli.HelpFormatter} processes ordinary {@code org.apache.commons.cli.Option}.
+ *
+ * It combines both {@code HelpMessageAsCliOption} and ordinary {@code org.apache.commons.cli.Option}, and
+ * builds the entire help message.
+ *
+ * It is visible only in {@code org.embulk.cli.parse} because it is an extension of a commons-cli class.
+ * Dependencies on third-party libraries are to be encapsulated.
+ */
+final class CliHelpFormatterWithHelpMessages
+        extends HelpFormatter
+{
+    CliHelpFormatterWithHelpMessages(final String syntaxPrefix, final int prefixWidth)
+    {
+        super();
+        this.prefixWidth = prefixWidth;
+        this.setSyntaxPrefix(syntaxPrefix);
+    }
+
+    @Override
+    public final void printHelp(
+            final PrintWriter printWriter,
+            final int width,
+            final String commandLineSyntax,
+            final String header,
+            final Options options,
+            final int leftPaddingWidth,
+            final int descriptionPaddingWidth,
+            final String footer,
+            final boolean autoUsage)
+    {
+        super.printHelp(printWriter,
+                        width,
+                        commandLineSyntax,
+                        header,
+                        options,
+                        leftPaddingWidth,
+                        descriptionPaddingWidth,
+                        footer,
+                        autoUsage);
+        printWriter.flush();
+    }
+
+    @Override
+    protected final StringBuffer renderOptions(
+            final StringBuffer buffer,
+            final int width,
+            final Options options,
+            final int leftPaddingWidth,
+            final int descriptionPaddingWidth)
+    {
+        // If |options| is not the extended version, it is just delegated to the original HelpFormatter.
+        if (!(options instanceof CliOptionsWithHelpMessages)) {
+            return super.renderOptions(buffer, width, options, leftPaddingWidth, descriptionPaddingWidth);
+        }
+
+        final List<Option> allOptions = ((CliOptionsWithHelpMessages) options).getAllOptions();
+        final String leftPadding = super.createPadding(leftPaddingWidth);
+        final String descriptionPadding = super.createPadding(descriptionPaddingWidth);
+
+        int maxOptionLinePrefixLength = 0;
+        final HashMap<Option, String> optionLinePrefixes = new HashMap<Option, String>();
+
+        // The first pass: builds all "prefixes" of option lines, and measures their length.
+        for (final Option option : allOptions) {
+            final StringBuilder optionLinePrefixBuilder = new StringBuilder();
+
+            if (!(option instanceof HelpMessageAsCliOption)) {
+                optionLinePrefixBuilder.append(leftPadding);
+                if (option.getOpt() == null) {
+                    optionLinePrefixBuilder.append("    ").append(getLongOptPrefix()).append(option.getLongOpt());
+                }
+                else {
+                    optionLinePrefixBuilder.append(getOptPrefix()).append(option.getOpt());
+                    if (option.hasLongOpt()) {
+                        optionLinePrefixBuilder.append(", ").append(getLongOptPrefix()).append(option.getLongOpt());
+                    }
+                }
+
+                if (option.hasArg()) {
+                    final String argName = option.getArgName();
+                    if (argName != null && argName.length() == 0) {
+                        optionLinePrefixBuilder.append(' ');
+                    }
+                    else {
+                        optionLinePrefixBuilder.append(option.hasLongOpt() ? getLongOptSeparator() : " ");
+                        optionLinePrefixBuilder.append(argName != null ? option.getArgName() : getArgName());
+                    }
+                }
+
+                optionLinePrefixes.put(option, optionLinePrefixBuilder.toString());
+                if (maxOptionLinePrefixLength < optionLinePrefixBuilder.length()) {
+                    maxOptionLinePrefixLength = optionLinePrefixBuilder.length();
+                }
+            }
+        }
+
+        if (maxOptionLinePrefixLength < this.prefixWidth) {
+            maxOptionLinePrefixLength = this.prefixWidth;
+        }
+
+        // The second pass: builds all lines both from options and help messages.
+        for (final Option option : allOptions) {
+            if (option instanceof HelpMessageAsCliOption) {
+                buffer.append(option.toString());
+            }
+            else {
+                final StringBuilder lineBuilder = new StringBuilder();
+                lineBuilder.append(optionLinePrefixes.get(option));
+                if (lineBuilder.length() < maxOptionLinePrefixLength) {
+                    lineBuilder.append(super.createPadding(maxOptionLinePrefixLength - lineBuilder.length()));
+                }
+                lineBuilder.append(descriptionPadding);
+
+                if (option.getDescription() != null) {
+                    lineBuilder.append(option.getDescription());
+                }
+                super.renderWrappedText(buffer,
+                                        width,
+                                        maxOptionLinePrefixLength + descriptionPaddingWidth,
+                                        lineBuilder.toString());
+            }
+            buffer.append(super.getNewLine());
+        }
+        return buffer;
+    }
+
+    private final int prefixWidth;
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/CliOptionsWithHelpMessages.java

@@ -0,0 +1,45 @@
+package org.embulk.cli.parse;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+
+/**
+ * CliOptionsWithHelpMessages is an extension of commons-cli's org.apache.commons.cli.Options.
+ *
+ * It just recognizes {@code HelpMessageAsCliOption} while others are same with {@code org.apache.commons.cli.Options}.
+ * {@code HelpMessageAsCliOption} is added just as a help message line, but ignored as a command line option.
+ *
+ * It is visible only in |org.embulk.cli.parse| because it is an extension of a commons-cli class.
+ * Dependencies on third-party libraries are to be encapsulated.
+ */
+final class CliOptionsWithHelpMessages
+        extends Options
+{
+    CliOptionsWithHelpMessages()
+    {
+        this.allOptions = new ArrayList<Option>();
+    }
+
+    /**
+     * Adds commons-cli's {@code org.apache.commons.cli.Option}.
+     */
+    @Override
+    public final Options addOption(final Option option)
+    {
+        this.allOptions.add(option);
+        if (option instanceof HelpMessageAsCliOption) {
+            return this;
+        }
+        return super.addOption(option);
+    }
+
+    final List<Option> getAllOptions()
+    {
+        return Collections.unmodifiableList(this.allOptions);
+    }
+
+    private final ArrayList<Option> allOptions;
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/EmbulkCommandLineHelpRequired.java

@@ -0,0 +1,10 @@
+package org.embulk.cli.parse;
+
+public final class EmbulkCommandLineHelpRequired
+        extends Throwable
+{
+    EmbulkCommandLineHelpRequired()
+    {
+        super();
+    }
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/EmbulkCommandLineParseException.java

@@ -0,0 +1,25 @@
+package org.embulk.cli.parse;
+
+public final class EmbulkCommandLineParseException
+        extends Exception
+{
+    protected EmbulkCommandLineParseException()
+    {
+        super();
+    }
+
+    public EmbulkCommandLineParseException(final String message)
+    {
+        super(message);
+    }
+
+    public EmbulkCommandLineParseException(final Throwable cause)
+    {
+        super(cause);
+    }
+
+    public EmbulkCommandLineParseException(final String message, final Throwable cause)
+    {
+        super(message, cause);
+    }
+}

data/embulk-cli/src/main/java/org/embulk/cli/parse/EmbulkCommandLineParser.java

@@ -0,0 +1,183 @@
+package org.embulk.cli.parse;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.ParseException;
+import org.embulk.cli.EmbulkCommandLine;
+
+public class EmbulkCommandLineParser
+{
+    private EmbulkCommandLineParser(
+            final String usage,
+            final List<AbstractHelpLineDefinition> helpLineDefinitions,
+            final int minArgs,
+            final int maxArgs,
+            final int width)
+    {
+        this.usage = usage;
+        this.helpLineDefinitions = Collections.unmodifiableList(helpLineDefinitions);
+        this.minArgs = minArgs;
+        this.maxArgs = maxArgs;
+        this.width = width;
+
+        this.cliOptions = new CliOptionsWithHelpMessages();
+
+        final HashMap<Option, OptionDefinition> optionDefinitionFromCliOption = new HashMap<Option, OptionDefinition>();
+        for (final AbstractHelpLineDefinition definition : this.helpLineDefinitions) {
+            cliOptions.addOption(definition.getCliOption());
+            if (definition instanceof OptionDefinition) {
+                optionDefinitionFromCliOption.put(definition.getCliOption(), ((OptionDefinition) definition));
+            }
+        }
+        this.optionDefinitionFromCliOption = optionDefinitionFromCliOption;
+    }
+
+    public static class Builder
+    {
+        private Builder()
+        {
+            this.mainUsage = null;
+            this.additionalUsage = new StringBuilder();
+            this.helpLineDefinitions = new ArrayList<AbstractHelpLineDefinition>();
+            this.minArgs = 0;
+            this.maxArgs = Integer.MAX_VALUE;
+            this.width = 74;
+        }
+
+        public EmbulkCommandLineParser build()
+        {
+            return new EmbulkCommandLineParser(
+                this.mainUsage + this.additionalUsage.toString(),
+                this.helpLineDefinitions,
+                this.minArgs,
+                this.maxArgs,
+                this.width);
+        }
+
+        public Builder setMainUsage(final String mainUsage)
+        {
+            this.mainUsage = mainUsage;
+            return this;
+        }
+
+        public Builder addUsage(final String line)
+        {
+            this.additionalUsage.append(System.getProperty("line.separator"));
+            this.additionalUsage.append(line);
+            return this;
+        }
+
+        public Builder addOptionDefinition(final OptionDefinition optionDefinition)
+        {
+            this.helpLineDefinitions.add(optionDefinition);
+            return this;
+        }
+
+        public Builder addHelpMessageLine(final String message)
+        {
+            this.helpLineDefinitions.add(new HelpMessageLineDefinition(message));
+            return this;
+        }
+
+        public Builder setArgumentsRange(final int minArgs, final int maxArgs)
+        {
+            this.minArgs = minArgs;
+            this.maxArgs = maxArgs;
+            return this;
+        }
+
+        public Builder setWidth(final int width)
+        {
+            this.width = width;
+            return this;
+        }
+
+        private String mainUsage;
+        private final StringBuilder additionalUsage;
+        private final ArrayList<AbstractHelpLineDefinition> helpLineDefinitions;
+        private int minArgs;
+        private int maxArgs;
+        private int width;
+    }
+
+    public static Builder builder()
+    {
+        return new Builder();
+    }
+
+    public EmbulkCommandLine parse(final List<String> argsEmbulk,
+                                   final PrintWriter helpPrintWriter,
+                                   final PrintWriter errorPrintWriter)
+            throws EmbulkCommandLineParseException, EmbulkCommandLineHelpRequired
+    {
+        final CommandLine cliCommandLine;
+        try {
+            cliCommandLine = new DefaultParser().parse(
+                this.cliOptions, argsEmbulk.toArray(new String[argsEmbulk.size()]));
+        }
+        catch (ParseException ex) {
+            throw new EmbulkCommandLineParseException(ex.getMessage(), ex);
+        }
+
+        for (final Option cliOptionSpecified : cliCommandLine.getOptions()) {
+            final OptionDefinition optionDefinitionSpecified =
+                this.optionDefinitionFromCliOption.get(cliOptionSpecified);
+
+            if (optionDefinitionSpecified.printsHelp()) {
+                throw new EmbulkCommandLineHelpRequired();
+            }
+        }
+
+        final List<String> arguments = cliCommandLine.getArgList();
+        if (arguments.size() < this.minArgs) {
+            throw new EmbulkCommandLineParseException("Too few arguments.");
+        }
+        if (arguments.size() > this.maxArgs) {
+            throw new EmbulkCommandLineParseException("Too many arguments;");
+        }
+
+        final EmbulkCommandLine.Builder commandLineBuilder = EmbulkCommandLine.builder();
+        commandLineBuilder.addArguments(arguments);
+        for (final Option cliOptionSpecified : cliCommandLine.getOptions()) {
+            final OptionDefinition optionDefinitionSpecified =
+                this.optionDefinitionFromCliOption.get(cliOptionSpecified);
+            optionDefinitionSpecified.behave(commandLineBuilder, cliOptionSpecified.getValue());
+        }
+
+        return commandLineBuilder.build();
+    }
+
+    public final void printHelp(final PrintStream printStream)
+    {
+        this.printHelp(new PrintWriter(printStream));
+    }
+
+    public void printHelp(final PrintWriter printWriter)
+    {
+        final CliHelpFormatterWithHelpMessages helpFormatter = new CliHelpFormatterWithHelpMessages("Usage: ", 32);
+        helpFormatter.printHelp(printWriter,  // PrintWriter pw
+                                this.width,  // int width
+                                this.usage,  // String cmdLineSyntax
+                                "",  // String header
+                                this.cliOptions,  // Options options
+                                4,  // int leftPad
+                                5,  // int descPad
+                                ""  // String footer
+                                );
+    }
+
+    private final String usage;
+    private final List<AbstractHelpLineDefinition> helpLineDefinitions;
+    private final int minArgs;
+    private final int maxArgs;
+    private final int width;
+    private final CliOptionsWithHelpMessages cliOptions;
+    private final HashMap<Option, OptionDefinition> optionDefinitionFromCliOption;
+}