embulk 0.10.26-java → 0.10.27-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37c5b862011b9f51b60707e073634c4d5f93a958
-  data.tar.gz: 605d208a67523de7e3fc0e89a5150694365b7799
+  metadata.gz: f38ba95abc72fbadd053d8b57f7b1513ae15a55e
+  data.tar.gz: 0326ed992defdc94711bf9dbf29d2166da13b0bd
 SHA512:
-  metadata.gz: 7fa4b558d76d6b58a299eb96ef838e611a66e665c71fb99e7a30bf918401c62f83dc30f222d74e3a4e903153e2d6c140f184117e0cda4d1de6a0b8895599251f
-  data.tar.gz: 309678e2d2e996dd60f84e1ae49eaafde413e45a7ccab5ad34d00c57fc163f1d5f49cf7f559acd2f0f919035050fceea08a292508366051e97b6d956aa33de69
+  metadata.gz: 72a48650886ff80ff88e9b481cf52bdd557b5ff1d956814da6ba8659d8078dfb29668f71eb8a13d524ee22d1c19da3ac8d1c91c381bc579ddeb213c4f3fdafaa
+  data.tar.gz: d7dbb35669b4190eb072338649221a128314fd903c78a2f05be4a31e7f3da2811d51150a48ca9bdea4e943b3db0d6163e5b549cfaddb4eda98565f55a9f08e16

data/embulk.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name = "embulk"
-  gem.version = "0.10.26"
+  gem.version = "0.10.27"
   gem.license = "Apache-2.0"
 
   gem.summary = "Embulk's runtime library for Ruby."
@@ -33,7 +33,7 @@ Gem::Specification.new do |gem|
       "documentation_uri" => "https://www.embulk.org/",
       "homepage_uri" => gem.homepage,
       # "mailing_list_uri"  => "",
-      "source_code_uri" => "https://github.com/embulk/embulk/tree/v0.10.26",
+      "source_code_uri" => "https://github.com/embulk/embulk/tree/v0.10.27",
       # "wiki_uri" => "",
     }
   end

data/lib/embulk/gem_version.rb

@@ -1,3 +1,3 @@
 module Embulk
-  GEM_VERSION_EMBEDDED = "0.10.26"
+  GEM_VERSION_EMBEDDED = "0.10.27"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: embulk
 version: !ruby/object:Gem::Version
-  version: 0.10.26
+  version: 0.10.27
 platform: java
 authors:
 - Sadayuki Furuhashi
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-28 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -52,12 +52,7 @@ files:
 - lib/embulk/filter_plugin.rb
 - lib/embulk/formatter_plugin.rb
 - lib/embulk/gem_version.rb
-- lib/embulk/guess/bzip2.rb
 - lib/embulk/guess/charset.rb
-- lib/embulk/guess/csv.rb
-- lib/embulk/guess/csv_all_strings.rb
-- lib/embulk/guess/gzip.rb
-- lib/embulk/guess/json.rb
 - lib/embulk/guess/newline.rb
 - lib/embulk/guess/schema_guess.rb
 - lib/embulk/guess/time_format_guess.rb
@@ -83,7 +78,7 @@ metadata:
   changelog_uri: https://github.com/embulk/embulk/releases
   documentation_uri: https://www.embulk.org/
   homepage_uri: https://www.embulk.org/
-  source_code_uri: https://github.com/embulk/embulk/tree/v0.10.26
+  source_code_uri: https://github.com/embulk/embulk/tree/v0.10.27
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/embulk/guess/bzip2.rb

@@ -1,23 +0,0 @@
-module Embulk
-  module Guess
-
-    class Bzip2GuessPlugin < GuessPlugin
-      Plugin.register_guess('bzip2', self)
-
-      # magic: BZ
-      # version: 'h' = bzip2
-      # blocksize: 1 .. 9
-      # block magic: 0x314159265359 (6 bytes)
-      block_magic = [0x31, 0x41, 0x59, 0x26, 0x53, 0x59].pack('C*')
-      BZIP2_HEADER_PATTERN = /BZh[1-9]#{Regexp.quote(block_magic)}/n
-
-      def guess(config, sample_buffer)
-        if sample_buffer[0,10] =~ BZIP2_HEADER_PATTERN
-          return {"decoders" => [{"type" => "bzip2"}]}
-        end
-        return {}
-      end
-    end
-
-  end
-end

data/lib/embulk/guess/csv.rb

@@ -1,374 +0,0 @@
-module Embulk
-  module Guess
-    require 'embulk/guess/schema_guess'
-
-    class CsvGuessPlugin < LineGuessPlugin
-      Plugin.register_guess('csv', self)
-
-      DELIMITER_CANDIDATES = [
-        ",", "\t", "|", ";"
-      ]
-
-      QUOTE_CANDIDATES = [
-        "\"", "'"
-      ]
-
-      ESCAPE_CANDIDATES = [
-        "\\", '"'
-      ]
-
-      NULL_STRING_CANDIDATES = [
-        "null",
-        "NULL",
-        "#N/A",
-        "\\N",  # MySQL LOAD, Hive STORED AS TEXTFILE
-      ]
-
-      COMMENT_LINE_MARKER_CANDIDATES = [
-        "#",
-        "//",
-      ]
-
-      MAX_SKIP_LINES = 10
-      NO_SKIP_DETECT_LINES = 10
-
-      def guess_lines(config, sample_lines)
-        return {} unless config.fetch("parser", {}).fetch("type", "csv") == "csv"
-
-        parser_config = config["parser"] || {}
-        if parser_config["type"] == "csv" && parser_config["delimiter"]
-          delim = parser_config["delimiter"]
-        else
-          delim = guess_delimiter(sample_lines)
-          unless delim
-            # assuming single column CSV
-            delim = DELIMITER_CANDIDATES.first
-          end
-        end
-
-        parser_guessed = DataSource.new.merge(parser_config).merge({"type" => "csv", "delimiter" => delim})
-
-        unless parser_guessed.has_key?("quote")
-          quote = guess_quote(sample_lines, delim)
-          unless quote
-            if !guess_force_no_quote(sample_lines, delim, '"')
-              # assuming CSV follows RFC for quoting
-              quote = '"'
-            else
-              # disable quoting (set null)
-            end
-          end
-          parser_guessed["quote"] = quote
-        end
-        parser_guessed["quote"] = '"' if parser_guessed["quote"] == ''  # setting '' is not allowed any more. this line converts obsoleted config syntax to explicit syntax.
-
-        unless parser_guessed.has_key?("escape")
-          if quote = parser_guessed["quote"]
-            escape = guess_escape(sample_lines, delim, quote)
-            unless escape
-              if quote == '"'
-                # assuming this CSV follows RFC for escaping
-                escape = '"'
-              else
-                # disable escaping (set null)
-              end
-            end
-            parser_guessed["escape"] = escape
-          else
-            # escape does nothing if quote is disabled
-          end
-        end
-
-        unless parser_guessed.has_key?("null_string")
-          null_string = guess_null_string(sample_lines, delim)
-          parser_guessed["null_string"] = null_string if null_string
-          # don't even set null_string to avoid confusion of null and 'null' in YAML format
-        end
-
-        # guessing skip_header_lines should be before guessing guess_comment_line_marker
-        # because lines supplied to CsvTokenizer already don't include skipped header lines.
-        # skipping empty lines is also disabled here because skipping header lines is done by
-        # CsvParser which doesn't skip empty lines automatically
-        sample_records = split_lines(parser_guessed, false, sample_lines, delim, {})
-        skip_header_lines = guess_skip_header_lines(sample_records)
-        sample_lines = sample_lines[skip_header_lines..-1]
-        sample_records = sample_records[skip_header_lines..-1]
-
-        unless parser_guessed.has_key?("comment_line_marker")
-          comment_line_marker, sample_lines =
-            guess_comment_line_marker(sample_lines, delim, parser_guessed["quote"], parser_guessed["null_string"])
-          if comment_line_marker
-            parser_guessed["comment_line_marker"] = comment_line_marker
-          end
-        end
-
-        sample_records = split_lines(parser_guessed, true, sample_lines, delim, {})
-
-        # It should fail if CSV parser cannot parse sample_lines.
-        if sample_records.nil? || sample_records.empty?
-          return {}
-        end
-
-        if sample_lines.size == 1
-          # The file contains only 1 line. Assume that there are no header line.
-          header_line = false
-
-          column_types = SchemaGuess.types_from_array_records(sample_records[0, 1])
-
-          unless parser_guessed.has_key?("trim_if_not_quoted")
-            sample_records_trimmed = split_lines(parser_guessed, true, sample_lines, delim, {"trim_if_not_quoted" => true})
-            column_types_trimmed = SchemaGuess.types_from_array_records(sample_records_trimmed)
-            if column_types != column_types_trimmed
-              parser_guessed["trim_if_not_quoted"] = true
-              column_types = column_types_trimmed
-            else
-              parser_guessed["trim_if_not_quoted"] = false
-            end
-          end
-        else
-          # The file contains more than 1 line. If guessed first line's column types are all strings or boolean, and the types are
-          # different from the other lines, assume that the first line is column names.
-          first_types = SchemaGuess.types_from_array_records(sample_records[0, 1])
-          other_types = SchemaGuess.types_from_array_records(sample_records[1..-1] || [])
-
-          unless parser_guessed.has_key?("trim_if_not_quoted")
-            sample_records_trimmed = split_lines(parser_guessed, true, sample_lines, delim, {"trim_if_not_quoted" => true})
-            other_types_trimmed = SchemaGuess.types_from_array_records(sample_records_trimmed[1..-1] || [])
-            if other_types != other_types_trimmed
-              parser_guessed["trim_if_not_quoted"] = true
-              other_types = other_types_trimmed
-            else
-              parser_guessed["trim_if_not_quoted"] = false
-            end
-          end
-
-          header_line = (first_types != other_types && first_types.all? {|t| ["string", "boolean"].include?(t) }) || guess_string_header_line(sample_records)
-          column_types = other_types
-        end
-
-        if column_types.empty?
-          # TODO here is making the guessing failed if the file doesn't contain any columns. However,
-          #      this may not be convenient for users.
-          return {}
-        end
-
-        if header_line
-          parser_guessed["skip_header_lines"] = skip_header_lines + 1
-        else
-          parser_guessed["skip_header_lines"] = skip_header_lines
-        end
-
-        parser_guessed["allow_extra_columns"] = false unless parser_guessed.has_key?("allow_extra_columns")
-        parser_guessed["allow_optional_columns"] = false unless parser_guessed.has_key?("allow_optional_columns")
-
-        if header_line
-          column_names = sample_records.first.map(&:strip)
-        else
-          column_names = (0..column_types.size).to_a.map {|i| "c#{i}" }
-        end
-        schema = []
-        column_names.zip(column_types).each do |name,type|
-          if name && type
-            schema << new_column(name, type)
-          end
-        end
-        parser_guessed["columns"] = schema
-
-        return {"parser" => parser_guessed}
-      end
-
-      def new_column(name, type)
-        if type.is_a?(SchemaGuess::TimestampTypeMatch)
-          {"name" => name, "type" => type, "format" => type.format}
-        else
-          {"name" => name, "type" => type}
-        end
-      end
-
-      private
-
-      def split_lines(parser_config, skip_empty_lines, sample_lines, delim, extra_config)
-        null_string = parser_config["null_string"]
-        config = parser_config.merge(extra_config).merge({"charset" => "UTF-8", "columns" => []})
-        parser_task = config.load_config(org.embulk.standards.CsvParserPlugin::PluginTask)
-        data = sample_lines.map {|line| line.force_encoding('UTF-8') }.join(parser_task.getNewline.getString.encode('UTF-8'))
-        sample = Buffer.from_ruby_string(data)
-        decoder = Java::LineDecoder.new(Java::ListFileInput.new([[sample.to_java]]), parser_task)
-        tokenizer = org.embulk.standards.CsvTokenizer.new(decoder, parser_task)
-        rows = []
-        while tokenizer.nextFile
-          while tokenizer.nextRecord(skip_empty_lines)
-            begin
-              columns = []
-              while true
-                begin
-                  column = tokenizer.nextColumn
-                  quoted = tokenizer.wasQuotedColumn
-                  if null_string && !quoted && column == null_string
-                    column = nil
-                  end
-                  columns << column
-                rescue org.embulk.standards.CsvTokenizer::TooFewColumnsException
-                  rows << columns
-                  break
-                end
-              end
-            rescue org.embulk.standards.CsvTokenizer::InvalidValueException
-              # TODO warning
-              tokenizer.skipCurrentLine
-            end
-          end
-        end
-        return rows
-      rescue
-        # TODO warning if fallback to this ad-hoc implementation
-        sample_lines.map {|line| line.split(delim) }
-      end
-
-      def guess_delimiter(sample_lines)
-        delim_weights = DELIMITER_CANDIDATES.map do |d|
-          counts = sample_lines.map {|line| line.count(d) }
-          total = array_sum(counts)
-          if total > 0
-            stddev = array_standard_deviation(counts)
-            stddev = 0.000000001 if stddev == 0.0
-            weight = total / stddev
-            [d, weight]
-          else
-            [nil, 0]
-          end
-        end
-
-        delim, weight = *delim_weights.sort_by {|d,weight| weight }.last
-        if delim != nil && weight > 1
-          return delim
-        else
-          return nil
-        end
-      end
-
-      def guess_quote(sample_lines, delim)
-        delim_regexp = Regexp.escape(delim)
-        quote_weights = QUOTE_CANDIDATES.map do |q|
-          weights = sample_lines.map do |line|
-            q_regexp = Regexp.escape(q)
-            count = line.count(q)
-            if count > 0
-              weight = count
-              weight += line.scan(/(?:\A|#{delim_regexp})\s*#{q_regexp}(?:(?!#{q_regexp}).)*\s*#{q_regexp}(?:$|#{delim_regexp})/).size * 20
-              weight += line.scan(/(?:\A|#{delim_regexp})\s*#{q_regexp}(?:(?!#{delim_regexp}).)*\s*#{q_regexp}(?:$|#{delim_regexp})/).size * 40
-              weight
-            else
-              nil
-            end
-          end.compact
-          weights.empty? ? 0 : array_avg(weights)
-        end
-        quote, weight = QUOTE_CANDIDATES.zip(quote_weights).sort_by {|q,w| w }.last
-        if weight >= 10.0
-          return quote
-        else
-          return nil
-        end
-      end
-
-      def guess_force_no_quote(sample_lines, delim, quote_candidate)
-        delim_regexp = Regexp.escape(delim)
-        q_regexp = Regexp.escape(quote_candidate)
-        sample_lines.any? do |line|
-          # quoting character appear at the middle of a non-quoted value
-          line =~ /(?:\A|#{delim_regexp})\s*[^#{q_regexp}]+#{q_regexp}/
-        end
-      end
-
-      def guess_escape(sample_lines, delim, quote)
-        guessed = ESCAPE_CANDIDATES.map do |str|
-          regexp = /#{Regexp.quote(str)}(?:#{Regexp.quote(delim)}|#{Regexp.quote(quote)})/
-          counts = sample_lines.map {|line| line.scan(regexp).count }
-          count = counts.inject(0) {|r,c| r + c }
-          [str, count]
-        end.select {|str,count| count > 0 }.sort_by {|str,count| -count }
-        found = guessed.first
-        return found ? found[0] : nil
-      end
-
-      def guess_null_string(sample_lines, delim)
-        guessed = NULL_STRING_CANDIDATES.map do |str|
-          regexp = /(?:^|#{Regexp.quote(delim)})#{Regexp.quote(str)}(?:$|#{Regexp.quote(delim)})/
-          counts = sample_lines.map {|line| line.scan(regexp).count }
-          count = counts.inject(0) {|r,c| r + c }
-          [str, count]
-        end.select {|str,count| count > 0 }.sort_by {|str,count| -count }
-        found_str, found_count = guessed.first
-        return found_str ? found_str : nil
-      end
-
-      def guess_skip_header_lines(sample_records)
-        counts = sample_records.map {|records| records.size }
-        (1..[MAX_SKIP_LINES, counts.length - 1].min).each do |i|
-          check_row_count = counts[i-1]
-          if counts[i, NO_SKIP_DETECT_LINES].all? {|c| c <= check_row_count }
-            return i - 1
-          end
-        end
-        return 0
-      end
-
-      def guess_comment_line_marker(sample_lines, delim, quote, null_string)
-        exclude = []
-        exclude << /^#{Regexp.escape(quote)}/ if quote && !quote.empty?
-        exclude << /^#{Regexp.escape(null_string)}(?:#{Regexp.escape(delim)}|$)/ if null_string
-
-        guessed = COMMENT_LINE_MARKER_CANDIDATES.map do |str|
-          regexp = /^#{Regexp.quote(str)}/
-          unmatch_lines = sample_lines.reject do |line|
-            exclude.all? {|ex| line !~ ex } && line =~ regexp
-          end
-          match_count = sample_lines.size - unmatch_lines.size
-          [str, match_count, unmatch_lines]
-        end.select {|str,match_count,unmatch_lines| match_count > 0 }.sort_by {|str,match_count,unmatch_lines| -match_count }
-
-        str, match_count, unmatch_lines = guessed.first
-        if str
-          return str, unmatch_lines
-        else
-          return nil, sample_lines
-        end
-      end
-
-      def guess_string_header_line(sample_records)
-        first = sample_records.first
-        first.count.times do |column_index|
-          lengths = sample_records.map {|row| row[column_index] }.compact.map {|v| v.to_s.size }
-          if lengths.size > 1
-            if array_variance(lengths[1..-1]) <= 0.2
-              avg = array_avg(lengths[1..-1])
-              if avg == 0.0 ? lengths[0] > 1 : (avg - lengths[0]).abs / avg > 0.7
-                return true
-              end
-            end
-          end
-        end
-        return false
-      end
-
-      def array_sum(array)
-        array.inject(0) {|r,i| r += i }
-      end
-
-      def array_avg(array)
-        array.inject(0.0) {|r,i| r += i } / array.size
-      end
-
-      def array_variance(array)
-        avg = array_avg(array)
-        array.inject(0.0) {|r,i| r += (i - avg) ** 2 } / array.size
-      end
-
-      def array_standard_deviation(array)
-        Math.sqrt(array_variance(array))
-      end
-    end
-
-  end
-end

data/lib/embulk/guess/csv_all_strings.rb

@@ -1,13 +0,0 @@
-module Embulk
-  module Guess
-    require 'embulk/guess/csv'
-
-    class CsvAllStringsGuessPlugin < CsvGuessPlugin
-      Plugin.register_guess("csv_all_strings", self)
-
-      def new_column(name, type)
-        {"name" => name, "type" => "string"}
-      end
-    end
-  end
-end

data/lib/embulk/guess/gzip.rb

@@ -1,18 +0,0 @@
-module Embulk
-  module Guess
-
-    class GzipGuessPlugin < GuessPlugin
-      Plugin.register_guess('gzip', self)
-
-      GZIP_HEADER = "\x1f\x8b".force_encoding('ASCII-8BIT').freeze
-
-      def guess(config, sample_buffer)
-        if sample_buffer[0,2] == GZIP_HEADER
-          return {"decoders" => [{"type" => "gzip"}]}
-        end
-        return {}
-      end
-    end
-
-  end
-end

data/lib/embulk/guess/json.rb

@@ -1,50 +0,0 @@
-module Embulk
-  module Guess
-    class JsonGuessPlugin < GuessPlugin
-      Plugin.register_guess('json', self)
-
-      java_import 'com.google.common.collect.Lists'
-      java_import 'java.io.ByteArrayInputStream'
-      java_import 'org.embulk.spi.Exec'
-      java_import 'org.embulk.spi.json.JsonParser'
-      java_import 'org.embulk.spi.json.JsonParseException'
-      java_import 'org.embulk.spi.util.FileInputInputStream'
-      java_import 'org.embulk.spi.util.InputStreamFileInput'
-
-      def guess(config, sample_buffer)
-        return {} unless config.fetch("parser", {}).fetch("type", "json") == "json"
-
-        # Use org.embulk.spi.json.JsonParser to respond to multi-line Json
-        json_parser = new_json_parser(sample_buffer)
-        one_json_parsed = false
-        begin
-          while (v = json_parser.next)
-            # "v" needs to be JSON object type (isMapValue) because:
-            # 1) Single-column CSV can be mis-guessed as JSON if JSON non-objects are accepted.
-            # 2) JsonParserPlugin accepts only the JSON object type.
-            raise JsonParseException.new("v must be JSON object type") unless v.isMapValue
-            one_json_parsed = true
-          end
-        rescue JsonParseException
-          # the exception is ignored
-        end
-
-        if one_json_parsed
-          return {"parser" => {"type" => "json"}} # if JsonParser can parse even one JSON data
-        else
-          return {}
-        end
-      end
-
-      private
-
-      def new_json_parser(buffer)
-        input_streams = Lists::newArrayList(ByteArrayInputStream.new(buffer.to_java_bytes))
-        iterator_provider = InputStreamFileInput::IteratorProvider.new(input_streams)
-        input = FileInputInputStream.new(InputStreamFileInput.new(Java::SPI::Exec.getBufferAllocator(), iterator_provider))
-        input.nextFile
-        JsonParser.new.open(input)
-      end
-    end
-  end
-end