embulk 0.8.18 → 0.8.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d66941d7b936e34061caefed36090e468ecc370c
-  data.tar.gz: ae10e38c4b86ba5517469e00cf081a18fe77bc90
+  metadata.gz: 5fba9b7b6769b12e6aa2c98e87351fc0d6b42f67
+  data.tar.gz: d0b1e8ff0c35aca4f5ff09b15651e3165a0a7590
 SHA512:
-  metadata.gz: c850b9132ed2672a7f30719b8062f84b39b0dd9c03c79e35a540cf8c76105a1374b783e0760c517d4b44a11ad6df5fb9fea91b2a0c466099494dc38cee8610d9
-  data.tar.gz: 1aa158cd445c3639ec9f8b5c3a3c7c8857b3d640d3bdb4365ba29813712c60d02492473375219dce389a25270aed35f9ac1d462785781fe9c8934c42b036111b
+  metadata.gz: 33ad3c2b73943faee62ef25cdfb139b6f93e05ec63dda1f4434d3dbfb6e794c5d807bb7f2a330b809983f4ce1335888b7683e685ef5004c24131bb9149209871
+  data.tar.gz: e13412ceb92526513f6b5393df3fc792dfc4e7d5540d50ae06381362646dd05660136f038162ca8ead56727be33254d567aa31c86c68e8fceb7b087a8e980954

data/README.md

@@ -176,6 +176,16 @@ Task `dependencies` shows dependency tree of embulk-core project:
 ./gradlew :embulk-core:dependencies
 ```
 
+### Update JRuby
+
+Task `updateJRuby` updates JRuby version of embulk-core project.
+
+This is an example to update JRuby to `9.1.5.0`.
+
+```
+./gradlew updateJRuby -Pto=9.1.5.0
+```
+
 ### Documents
 
 Embulk uses Sphinx, YARD (Ruby API) and JavaDoc (Java API) for document generation.

data/build.gradle

@@ -16,7 +16,7 @@ def release_projects = [project(":embulk-core"), project(":embulk-standards"), p
 
 allprojects {
     group = 'org.embulk'
-    version = '0.8.18'
+    version = '0.8.19'
 
     ext {
         jrubyVersion = '9.1.5.0'
@@ -213,6 +213,9 @@ task cli(dependsOn: ':embulk-cli:shadowJar') {
         file('pkg').mkdirs()
         File f = file("pkg/embulk-${project.version}.jar")
         f.write("")
+        f.append("\n: <<END_OF_EMBULK_SELFRUN_BATCH_PART\r\n")
+        f.append(file("embulk-cli/src/main/bat/selfrun.bat").readBytes())
+        f.append("\r\nEND_OF_EMBULK_SELFRUN_BATCH_PART\r\n\n")
         f.append(file("embulk-cli/src/main/sh/selfrun.sh").readBytes())
         f.append(file("embulk-cli/build/libs/embulk-cli-${project.version}-all.jar").readBytes())
         f.setExecutable(true)
@@ -224,6 +227,8 @@ project(':embulk-cli') {
     apply plugin: 'com.github.johnrengelman.shadow'
 
     shadowJar {
+        // NOTE: This 'Implementation-Version' in the manifest is referred to provide the Embulk version at runtime.
+        // See also: embulk-core/src/main/java/org/embulk/EmbulkVersion.java
         manifest {
             attributes 'Implementation-Title': project.name,
                        'Implementation-Version': project.version,
@@ -329,8 +334,10 @@ task setVersion {
         File gradle_ver = file('build.gradle')
         gradle_ver.write(gradle_ver.getText().replaceFirst("version = '(\\d+)(\\.\\d+){2}'", "version = '${to}'"))
 
+        // TODO(v2)[#562]: Remove this part to update the version number in lib/embulk/version.rb.
+        // https://github.com/embulk/embulk/issues/562
         File ruby_ver = file('lib/embulk/version.rb')
-        ruby_ver.write(ruby_ver.getText().replaceFirst("VERSION = '(\\d+)(\\.\\d+){2}'", "VERSION = '${to}'"))
+        ruby_ver.write(ruby_ver.getText().replaceFirst("VERSION_INTERNAL = '(\\d+)(\\.\\d+){2}'", "VERSION_INTERNAL = '${to}'"))
 
         List<String> docs = [
             'README.md',
@@ -359,7 +366,7 @@ task updateJRuby {
         File gemspec_ver  = file('embulk.gemspec')
         gemspec_ver.write(gemspec_ver.getText().replaceFirst("gem.add_dependency \"jruby-jars\", '= (\\d+)(\\.\\d+){3}'", "gem.add_dependency \"jruby-jars\", '= ${to}'"))
 
-        File migrate_plugin_ver  = file('lib/embulk/command/embulk_migrate_plugin.rb')
+        File migrate_plugin_ver  = file('embulk-cli/src/main/java/org/embulk/cli/EmbulkMigrate.java')
         migrate_plugin_ver.write(migrate_plugin_ver.getText().replaceFirst("\".ruby-version\", \"jruby-(\\d+)(\\.\\d+){3}\"", "\".ruby-version\", \"jruby-${to}\""))
 
         File gemfile_lock_ver  = file('Gemfile.lock')

data/embulk-cli/build.gradle

@@ -1,6 +1,8 @@
 dependencies {
     compile project(':embulk-core')
     compile project(':embulk-standards')
+    compile 'org.apache.maven:maven-artifact:3.3.9'
+    compile 'org.apache.velocity:velocity:1.7'
 
     testCompile project(':embulk-core').sourceSets.test.output
 }

data/embulk-cli/src/main/bat/selfrun.bat

@@ -0,0 +1,98 @@
+@echo off
+
+setlocal
+
+set this=%~f0
+set java_args=
+set jruby_args=
+set default_optimize=
+set overwrite_optimize=
+set status=
+set error=
+set args=
+
+rem In jar file, cannot goto ahread for some reason.
+
+for %%a in ( %* ) do (
+    call :check_arg %%a
+)
+
+if "%error%" == "true" exit /b 1
+
+set optimize=false
+if "%overwrite_optimize%" == "true" (
+    set optimize=true
+) else (
+    if "%default_optimize%" == "true" (
+        if not "%overwrite_optimize%" == "false" (
+            set optimize=true
+        )
+    )
+)
+
+if "%optimize%" == "true" (
+    set java_args=-XX:+AggressiveOpts -XX:+UseConcMarkSweepGC %java_args%
+) else (
+    set java_args=-XX:+AggressiveOpts -XX:+TieredCompilation -XX:TieredStopAtLevel=1 -Xverify:none %java_args%
+)
+
+java %java_args% -jar %this% %jruby_args% %args%
+
+endlocal
+
+exit /b %ERRORLEVEL%
+
+:check_arg
+set arg=%*
+
+rem Remove double quotations
+set p1=%arg:~0,1%
+set p1=%p1:"=%
+set p2=%arg:~-1,1%
+set p2=%p2:"=%
+set arg=%p1%%arg:~1,-1%%p2%
+
+if "%status%" == "rest" (
+    set args=%args% %arg%
+
+) else if "%status%" == "read" (
+    call :read_file %arg%
+
+) else if "%arg%" == "-J+O" (
+    set overwrite_optimize=true
+    set status=rest
+
+) else if "%arg%" == "-J-O" (
+    set overwrite_optimize=false
+    set status=rest
+
+) else if "%arg:~0,2%" == "-J" (
+    if not "%arg:~2%" == "" (
+        set java_args=%java_args% %arg:~2%
+    ) else (
+        set status=read
+    )
+
+) else if "%arg:~0,2%" == "-R" (
+    set jruby_args=%jruby_args% %arg%
+
+) else if "%arg%" == "run" (
+    set default_optimize=true
+    set args=%args% %arg%
+    set status=rest
+
+) else (
+    set args=%args% %arg%
+    set status=rest
+)
+exit /b
+
+:read_file
+if not exist "%~1" (
+    echo "failed to load java argument file."
+    set error=true
+) else (
+    for /f "delims=" %%i in (%~1) do set java_args=%java_args% %%i
+)
+set status=
+exit /b

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

@@ -0,0 +1,82 @@
+package org.embulk.cli;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.zip.GZIPOutputStream;
+
+public class EmbulkExample
+{
+    public void createExample(final String basePathInString)
+            throws IOException
+    {
+        createExample(Paths.get(basePathInString));
+    }
+
+    public void createExample(final Path basePath)
+            throws IOException
+    {
+        // TODO(dmikurube): Log with a kind of loggers instead of |System.out|.
+        System.out.printf("Creating %s directory...\n", basePath.toString());
+
+        System.out.printf("  Creating %s/\n", basePath.toString());
+        final Path csvPath = basePath.resolve("csv");
+        Files.createDirectories(csvPath);
+        System.out.printf("  Creating %s/\n", csvPath.toString());
+
+        final Path csvSamplePath = csvPath.resolve("sample_01.csv.gz");
+        System.out.printf("  Creating %s\n", csvSamplePath.toString());
+        outputSampleCsv(csvSamplePath);
+
+        final Path ymlSamplePath = basePath.resolve("seed.yml");
+        System.out.printf("  Creating %s\n", ymlSamplePath.toString());
+        outputSampleYml(csvPath, ymlSamplePath);
+
+        System.out.println("");
+        System.out.println("Run following subcommands to try embulk:");
+        System.out.println("");
+        System.out.printf("   1. embulk guess %s -o config.yml\n", ymlSamplePath.toString());
+        System.out.println("   2. embulk preview config.yml");
+        System.out.println("   3. embulk run config.yml");
+        System.out.println("");
+    }
+
+    private void outputSampleCsv(final Path csvSamplePath)
+            throws IOException
+    {
+        // TODO(dmikurube): Move the data into Java resources.
+        StringBuilder csvBuilder = new StringBuilder();
+        csvBuilder.append("id,account,time,purchase,comment\n");
+        csvBuilder.append("1,32864,2015-01-27 19:23:49,20150127,embulk\n");
+        csvBuilder.append("2,14824,2015-01-27 19:01:23,20150127,embulk jruby\n");
+        csvBuilder.append("3,27559,2015-01-28 02:20:02,20150128,\"Embulk \"\"csv\"\" parser plugin\"\n");
+        csvBuilder.append("4,11270,2015-01-29 11:54:36,20150129,NULL\n");
+        csvBuilder.append("\n");
+        byte[] csvSample = csvBuilder.toString().getBytes(StandardCharsets.UTF_8);
+
+        try (GZIPOutputStream output = new GZIPOutputStream(Files.newOutputStream(csvSamplePath))) {
+            output.write(csvSample);
+        }
+    }
+
+    private void outputSampleYml(final Path csvPath, final Path ymlSamplePath)
+            throws IOException
+    {
+        // TODO(dmikurube): Move the data into Java resources.
+        StringBuilder ymlBuilder = new StringBuilder();
+        ymlBuilder.append("in:\n");
+        ymlBuilder.append("  type: file\n");
+        ymlBuilder.append(String.format("  path_prefix: \"%s\"\n",
+                                        csvPath.toAbsolutePath().resolve("sample_").toString()));
+        ymlBuilder.append("out:\n");
+        ymlBuilder.append("  type: stdout\n");
+        byte[] ymlSample = ymlBuilder.toString().getBytes(StandardCharsets.UTF_8);
+
+        try (OutputStream output = Files.newOutputStream(ymlSamplePath)) {
+            output.write(ymlSample);
+        }
+    }
+}

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

@@ -0,0 +1,458 @@
+package org.embulk.cli;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.FileSystems;
+import java.nio.file.FileVisitResult;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+import org.apache.maven.artifact.versioning.ComparableVersion;
+
+public class EmbulkMigrate
+{
+    public void migratePlugin(final String pathInString, final String thisEmbulkVersion)
+            throws IOException
+    {
+        migratePlugin(Paths.get(pathInString), thisEmbulkVersion);
+    }
+
+    public void migratePlugin(final Path path, final String thisEmbulkVersion)
+            throws IOException
+    {
+        final Migrator migrator = new Migrator(path);
+
+        List<Matcher> matchedEmbulkCoreInGradle = migrator.matchersRecursive("build.gradle", EMBULK_CORE_IN_GRADLE);
+        List<Matcher> matchedNewEmbulkInGemspec = migrator.matchersRecursive("*.gemspec", NEW_EMBULK_IN_GEMSPEC);
+        List<Matcher> matchedOldEmbulkInGemspec = migrator.matchersRecursive("*.gemspec", OLD_EMBULK_IN_GEMSPEC);
+
+        final Language language;
+        final ComparableVersion fromVersion;
+        if (!matchedEmbulkCoreInGradle.isEmpty()) {
+            language = Language.JAVA;
+            fromVersion = new ComparableVersion(matchedEmbulkCoreInGradle.get(0).group(1).replace("+", "0"));
+            System.out.printf("Detected Java plugin for Embulk %s...\n", fromVersion.toString());
+        }
+        else if (!matchedNewEmbulkInGemspec.isEmpty()) {
+            language = Language.RUBY;
+            fromVersion = new ComparableVersion(matchedNewEmbulkInGemspec.get(0).group(1));
+            System.out.printf("Detected Ruby plugin for Embulk %s...\n", fromVersion.toString());
+        }
+        else if (!matchedOldEmbulkInGemspec.isEmpty()) {
+            language = Language.RUBY;
+            fromVersion = new ComparableVersion("0.1.0");
+            System.out.println("Detected Ruby plugin for unknown Embulk version...");
+        }
+        else {
+            throw new RuntimeException("Failed to detect plugin language and dependency version");
+        }
+
+        switch (language) {
+        case JAVA:
+            migrateJavaPlugin(migrator, fromVersion, thisEmbulkVersion);
+            break;
+        case RUBY:
+            migrateRubyPlugin(migrator, fromVersion, thisEmbulkVersion);
+            break;
+        }
+
+        if (migrator.getModifiedFiles().isEmpty()) {
+            System.out.println("Done. No files are modified.");
+        }
+        else {
+            System.out.println("Done. Please check modifieid files.");
+        }
+    }
+
+    private void migrateJavaPlugin(final Migrator migrator,
+                                   final ComparableVersion fromVersion,
+                                   final String thisEmbulkVersion)
+                throws IOException
+    {
+        if (fromVersion.compareTo(new ComparableVersion("0.7.0")) < 0) {
+            // rename CommitReport to TaskReport
+            migrator.replaceRecursive("*.java", Pattern.compile("(CommitReport)"), 1, "TaskReport");
+            migrator.replaceRecursive("*.java", Pattern.compile("(commitReport)"), 1, "taskReport");
+        }
+
+        // upgrade gradle version
+        if (migrator.match("gradle/wrapper/gradle-wrapper.properties", GRADLE_VERSION_IN_WRAPPER)) {
+            // gradle < 3.2.1
+            migrator.copy("embulk/data/new/java/gradle/wrapper/gradle-wrapper.properties",
+                          "gradle/wrapper/gradle-wrapper.properties");
+            migrator.copy("embulk/data/new/java/gradle/wrapper/gradle-wrapper.jar",
+                          "gradle/wrapper/gradle-wrapper.jar");
+        }
+
+        // Add a method |jsonColumn| before the method |timestampColumn| which should exist.
+        if (!migrator.matchRecursive("*.java", JSON_COLUMN_METHOD_IN_ALL_JAVA)) {
+            final List<Matcher> matchers = migrator.matchersRecursive("*.java", TIMESTAMP_COLUMN_METHOD_IN_ALL_JAVA);
+            if (!matchers.isEmpty()) {
+                final String indent = matchers.get(0).group(1);
+                final String JSON_COLUMN_METHOD = Joiner.on("\n").join(
+                    "",
+                    indent + "public void jsonColumn(Column column) {",
+                    indent + "    throw new UnsupportedOperationException(\"This plugin doesn't support json type. Please try to upgrade version of the plugin using 'embulk gem update' command. If the latest version still doesn't support json type, please contact plugin developers, or change configuration of input plugin not to use json type.\");",
+                    indent + "}",
+                    "",
+                    indent + "@Override",
+                    "");
+                migrator.replaceRecursive("*.java",
+                                          TIMESTAMP_COLUMN_METHOD_AFTER_NEWLINE_IN_ALL_JAVA,
+                                          1,
+                                          JSON_COLUMN_METHOD);
+            }
+        }
+
+        // Add |sourceCompatibility| and |targetCompatibility| in build.gradle before |dependencies| existing.
+        if (!migrator.match("build.gradle", TARGET_COMPATIBILITY_IN_GRADLE)) {
+            migrator.insertLine("build.gradle", DEPENDENCIES_IN_GRADLE, new StringUpsert() {
+                    @Override
+                    public String getUpsertd(Matcher matcher) {
+                        return String.format("%stargetCompatibility = 1.7\n", matcher.group(1));
+                    }
+                });
+        }
+        if (!migrator.match("build.gradle", SOURCE_COMPATIBILITY_IN_GRADLE)) {
+            migrator.insertLine("build.gradle", TARGET_COMPATIBILITY_IN_GRADLE_WITH_INDENT, new StringUpsert() {
+                    @Override
+                    public String getUpsertd(Matcher matcher) {
+                        return String.format("%ssourceCompatibility = 1.7\n", matcher.group(1));
+                    }
+                });
+        }
+
+        // Add the |checkstyle| Gradle plugin before the |java| plugin.
+        if (!migrator.match("build.gradle", CHECKSTYLE_PLUGIN_IN_GRADLE)) {
+            migrator.insertLine("build.gradle", JAVA_PLUGIN_IN_GRADLE, new StringUpsert() {
+                    @Override
+                    public String getUpsertd(Matcher matcher) {
+                        return String.format("%sid%s%scheckstyle%s",
+                                             matcher.group(1),
+                                             matcher.group(2),
+                                             matcher.group(3),
+                                             matcher.group(3));
+                    }
+                });
+            migrator.copy("embulk/data/new/java/config/checkstyle/checkstyle.xml",
+                          "config/checkstyle/checkstyle.xml");
+        }
+
+        // Add |checkstyle| settings before the |gem| task existing.
+        if (!migrator.match("build.gradle", CHECKSTYLE_CONFIGURATION_IN_GRADLE)) {
+            migrator.copy("embulk/data/new/java/config/checkstyle/default.xml",
+                          "config/checkstyle/default.xml");
+            migrator.insertLine("build.gradle", GEM_TASK_IN_GRADLE, new StringUpsert() {
+                    @Override
+                    public String getUpsertd(Matcher matcher) {
+                        final Joiner joiner = Joiner.on("\n");
+                        final String indent = matcher.group(1);
+                        return joiner.join(
+                            indent + "checkstyle {",
+                            indent + "    configFile = file(\"${project.rootDir}/config/checkstyle/checkstyle.xml\")",
+                            indent + "    toolVersion = '6.14.1'",
+                            indent + "}",
+                            indent + "checkstyleMain {",
+                            indent + "    configFile = file(\"${project.rootDir}/config/checkstyle/default.xml\")",
+                            indent + "    ignoreFailures = true",
+                            indent + "}",
+                            indent + "checkstyleTest {",
+                            indent + "    configFile = file(\"${project.rootDir}/config/checkstyle/default.xml\")",
+                            indent + "    ignoreFailures = true",
+                            indent + "}",
+                            indent + "task checkstyle(type: Checkstyle) {",
+                            indent + "    classpath = sourceSets.main.output + sourceSets.test.output",
+                            indent + "    source = sourceSets.main.allJava + sourceSets.test.allJava",
+                            indent + "}");
+                    }
+                });
+        }
+
+        // Update |embulk-core| and |embulk-standards| versions depending.
+        migrator.replaceRecursive("build.gradle", EMBULK_CORE_OR_STANDARDS_IN_GRADLE, 1, thisEmbulkVersion);
+    }
+
+    private void migrateRubyPlugin(final Migrator migrator,
+                                   final ComparableVersion fromVersion,
+                                   final String thisEmbulkVersion)
+            throws IOException
+    {
+        migrator.write(".ruby-version", "jruby-9.1.5.0");
+
+        // Update |embulk| version depending.
+        if (fromVersion.compareTo(new ComparableVersion("0.1.0")) <= 0) {
+            // Add add_development_dependency.
+            migrator.insertLineRecursive("*.gemspec", DEVELOPMENT_DEPENDENCY_IN_GEMSPEC, new StringUpsert() {
+                    @Override
+                    public String getUpsertd(Matcher matcher) {
+                        return String.format("%s.add_development_dependency 'embulk', ['>= %s']",
+                                             matcher.group(1),
+                                             thisEmbulkVersion);
+                    }
+                });
+        }
+        else {
+            if (migrator.replaceRecursive("*.gemspec", EMBULK_DEPENDENCY_PRERELEASE_IN_GEMSPEC, 1,
+                                 ">= " + thisEmbulkVersion).isEmpty()) {
+                migrator.replaceRecursive("*.gemspec", EMBULK_DEPENDENCY_IN_GEMSPEC, 1, thisEmbulkVersion);
+            }
+        }
+    }
+
+    private class Migrator {
+        private Migrator(Path basePath) {
+            this.basePath = basePath;
+            this.modifiedFiles = new HashSet<Path>();
+        }
+
+        public Path getBasePath()
+        {
+            return this.basePath;
+        }
+
+        public Set<Path> getModifiedFiles()
+        {
+            return this.modifiedFiles;
+        }
+
+        public void copy(String sourceResourcePath, String destinationFileName)
+                throws IOException
+        {
+            Path destinationPath = this.basePath.resolve(destinationFileName);
+            Files.createDirectories(destinationPath.getParent());
+            Files.copy(EmbulkMigrate.class.getClassLoader().getResourceAsStream(sourceResourcePath), destinationPath);
+        }
+
+        public boolean match(String filePath, Pattern pattern)
+                throws IOException
+        {
+            final Matcher matcher = pattern.matcher(read(this.basePath.resolve(filePath)));
+            return matcher.find();
+        }
+
+        public boolean matchRecursive(String baseFileNameGlob, Pattern pattern)
+                throws IOException
+        {
+            return !matchersRecursive(baseFileNameGlob, pattern).isEmpty();
+        }
+
+        public List<Matcher> matchersRecursive(final String baseFileNameGlob, final Pattern pattern)
+                throws IOException
+        {
+            final ImmutableList.Builder<Matcher> matchers = ImmutableList.<Matcher>builder();
+            final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + baseFileNameGlob);
+            Files.walkFileTree(this.basePath, new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult visitFile(Path filePath, BasicFileAttributes attributes) throws IOException {
+                        if (pathMatcher.matches(filePath.getFileName())) {
+                            final Matcher matcher = pattern.matcher(read(filePath));
+                            if (matcher.find()) {
+                                matchers.add(matcher);
+                            }
+                        }
+                        return FileVisitResult.CONTINUE;
+                    }
+                });
+            return matchers.build();
+        }
+
+        public List<Matcher> replaceRecursive(final String baseFileNameGlob,
+                                              final Pattern pattern,
+                                              final int index,
+                                              final String immediate)
+                throws IOException
+        {
+            final ImmutableList.Builder<Matcher> matchers = ImmutableList.<Matcher>builder();
+            final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + baseFileNameGlob);
+            Files.walkFileTree(this.basePath, new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult visitFile(Path filePath, BasicFileAttributes attributes) throws IOException {
+                        if (pathMatcher.matches(filePath.getFileName())) {
+                            final String originalData = read(filePath);
+                            Matcher first = null;
+                            int position = 0;
+                            String modifiedData = originalData;
+                            while (position < modifiedData.length()) {
+                                final Matcher matcher = pattern.matcher(modifiedData.substring(position));
+                                if (!matcher.matches()) {
+                                    break;
+                                }
+                                if (first == null) {
+                                    first = matcher;
+                                }
+                                final String replacingString = immediate;
+                                modifiedData =
+                                    modifiedData.substring(0, matcher.start(index) - 1) +
+                                    replacingString +
+                                    modifiedData.substring(matcher.end(index));
+                                position =
+                                    matcher.start(index) +
+                                    replacingString.length() +
+                                    (matcher.end() - matcher.end(index));
+                            }
+                            if (first != null) {
+                                modify(filePath, modifiedData);
+                                matchers.add(first);
+                            }
+                        }
+                        return FileVisitResult.CONTINUE;
+                    }
+                });
+            return matchers.build();
+        }
+
+        public boolean insertLine(Path filePath, Pattern pattern, StringUpsert stringUpsert)
+                throws IOException
+        {
+            final String originalData = read(filePath);
+            final Matcher matcher = pattern.matcher(originalData);
+            if (matcher.find()) {
+                final String preMatch = originalData.substring(0, matcher.start());
+                final int lineNumber = preMatch.split("\n").length;
+                final String replacingString = stringUpsert.getUpsertd(matcher);
+                List<String> lines = new ArrayList<String>(Arrays.asList(originalData.split("\n")));
+                lines.add(lineNumber + 1, replacingString);
+                final String modifiedData = Joiner.on("\n").join(lines);
+                modify(filePath, modifiedData);
+                return true;
+            }
+            return false;
+        }
+
+        public boolean insertLine(String filePath, Pattern pattern, StringUpsert stringUpsert)
+                throws IOException
+        {
+            return insertLine(this.basePath.resolve(filePath), pattern, stringUpsert);
+        }
+
+        public void insertLineRecursive(final String baseFileNameGlob,
+                                        final Pattern pattern,
+                                        final StringUpsert stringUpsert)
+                throws IOException
+        {
+            final ImmutableList.Builder<Matcher> matchers = ImmutableList.<Matcher>builder();
+            final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher("glob:" + baseFileNameGlob);
+            Files.walkFileTree(this.basePath, new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult visitFile(Path filePath, BasicFileAttributes attributes) throws IOException {
+                        if (pathMatcher.matches(filePath.getFileName())) {
+                            insertLine(filePath, pattern, stringUpsert);
+                        }
+                        return FileVisitResult.CONTINUE;
+                    }
+                });
+        }
+
+        public void write(String fileName, String writtenData)
+                throws IOException
+        {
+            Path destinationPath = this.basePath.resolve(fileName);
+            Files.createDirectories(destinationPath.getParent());
+            modify(destinationPath, writtenData);
+        }
+
+        private void modify(Path filePath, String modifiedData)
+                throws IOException
+        {
+            final String originalData = read(filePath);
+            if (!originalData.equals(modifiedData)) {
+                Files.write(filePath, modifiedData.getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE);
+                if (!this.modifiedFiles.contains(filePath)) {
+                    if (originalData.isEmpty()) {
+                        System.out.printf("  Created %s\n", filePath.toString());
+                    }
+                    else {
+                        System.out.printf("  Modified %s\n", filePath.toString());
+                    }
+                    this.modifiedFiles.add(filePath);
+                }
+            }
+        }
+
+        private String read(Path filePath)
+                throws IOException
+        {
+            // assumes source code is written in UTF-8.
+            return new String(readBytes(filePath), StandardCharsets.UTF_8);
+        }
+
+        private byte[] readBytes(Path filePath)
+                throws IOException
+        {
+            try {
+                return Files.readAllBytes(filePath);
+            }
+            catch (NoSuchFileException ex) {
+                return new byte[0];
+            }
+        }
+
+        private final Path basePath;
+        private final Set<Path> modifiedFiles;
+    }
+
+    private interface StringUpsert {
+        public String getUpsertd(Matcher matcher);
+    }
+
+    private enum Language {
+        JAVA,
+        RUBY,
+        ;
+    }
+
+    private static final Pattern EMBULK_CORE_IN_GRADLE = Pattern.compile(
+        "org\\.embulk:embulk-core:([\\d\\.\\+]+)?");
+    private static final Pattern NEW_EMBULK_IN_GEMSPEC = Pattern.compile(
+        "add_(?:development_)?dependency\\s+\\W+embulk\\W+\\s+([\\d\\.]+)\\W+");
+    private static final Pattern OLD_EMBULK_IN_GEMSPEC = Pattern.compile(
+        "embulk-");
+    private static final Pattern GRADLE_VERSION_IN_WRAPPER = Pattern.compile(
+        "gradle-[23]\\.\\d+(\\.\\d+)?-/");
+    private static final Pattern JSON_COLUMN_METHOD_IN_ALL_JAVA = Pattern.compile(
+        "void\\s+jsonColumn");
+    private static final Pattern TIMESTAMP_COLUMN_METHOD_IN_ALL_JAVA = Pattern.compile(
+        "^(\\W+).*?void\\s+timestampColumn", Pattern.MULTILINE);
+    private static final Pattern TIMESTAMP_COLUMN_METHOD_AFTER_NEWLINE_IN_ALL_JAVA = Pattern.compile(
+        "(\\r?\\n)(\\W+).*?void\\s+timestampColumn");
+    private static final Pattern TARGET_COMPATIBILITY_IN_GRADLE = Pattern.compile(
+        "targetCompatibility");
+    private static final Pattern SOURCE_COMPATIBILITY_IN_GRADLE = Pattern.compile(
+        "sourceCompatibility");
+    private static final Pattern DEPENDENCIES_IN_GRADLE = Pattern.compile(
+        "^([ \\t]*)dependencies\\s*\\{", Pattern.MULTILINE);
+    private static final Pattern TARGET_COMPATIBILITY_IN_GRADLE_WITH_INDENT = Pattern.compile(
+        "^([ \\t]*)targetCompatibility", Pattern.MULTILINE);
+    private static final Pattern CHECKSTYLE_PLUGIN_IN_GRADLE = Pattern.compile(
+        "id\\s+(?<quote>[\"\'])checkstyle\\k<quote>");
+    private static final Pattern JAVA_PLUGIN_IN_GRADLE = Pattern.compile(
+        "^([ \t]*)id( +)([\"\'])java[\"\']", Pattern.MULTILINE);
+    private static final Pattern CHECKSTYLE_CONFIGURATION_IN_GRADLE = Pattern.compile(
+        "checkstyle\\s+\\{");
+    private static final Pattern GEM_TASK_IN_GRADLE = Pattern.compile(
+        "^([ \\t]*)task\\s+gem\\W.*\\{", Pattern.MULTILINE);
+    private static final Pattern EMBULK_CORE_OR_STANDARDS_IN_GRADLE = Pattern.compile(
+        "org\\.embulk:embulk-(?:core|standards):([\\d\\.\\+]+)?");
+    private static final Pattern DEVELOPMENT_DEPENDENCY_IN_GEMSPEC = Pattern.compile(
+        "([ \\t]*\\w+)\\.add_development_dependency");
+    private static final Pattern EMBULK_DEPENDENCY_PRERELEASE_IN_GEMSPEC = Pattern.compile(
+        "add_(?:development_)?dependency\\s+\\W+embulk\\W+\\s*(\\~\\>\\s*[\\d\\.]+)\\W+");
+    private static final Pattern EMBULK_DEPENDENCY_IN_GEMSPEC = Pattern.compile(
+        "add_(?:development_)?dependency\\s+\\W+embulk\\W+\\s*([\\d\\.]+)\\W+");
+}