class GroongaSynonym::CommandLine::Generator

Constants

AVAILABLE_FORMATS
AVAILABLE_SOURCES

Public Class Methods

new(output=nil) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 30
def initialize(output=nil)
  @source = AVAILABLE_SOURCES.first
  @format = AVAILABLE_FORMATS.first
  @table = nil
  @term_column = nil
  @synonyms_column = nil
  @synonyms_column_is_vector = true
  @output = output || "-"
  @defaults = {
    groonga: {
      table: "Thesaurus",
      term_column: "_key",
      synonyms_column: "synonyms",
    },
    pgroonga: {
      table: "thesaurus",
      term_column: "term",
      synonyms_column: "synonyms",
    },
  }
end

Public Instance Methods

run(args) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 52
def run(args)
  catch do |tag|
    parse_args(args, tag)
    source = create_source
    open_output do |output|
      generator = create_generator(source, output)
      generator.generate
      true
    end
  end
end

Private Instance Methods

create_generator(source, output) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 148
def create_generator(source, output)
  options = {
    output: output,
  }
  case @format
  when :groonga
    default = @defaults[:groonga]
    term_column = @term_column || default[:term_column]
    synonyms_column = @synonyms_column || default[:synonyms_column]
    options[:synonyms_column_is_vector] = @synonyms_column_is_vector
    GroongaGenerator.new(source,
                         term_column,
                         synonyms_column,
                         **options)
  when :pgroonga
    default = @defaults[:pgroonga]
    table = @table || default[:table]
    term_column = @term_column || default[:term_column]
    synonyms_column = @synonyms_column || default[:synonyms_column]
    PGroongaGenerator.new(source,
                          table,
                          term_column,
                          synonyms_column,
                          **options)
  end
end
create_source() click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 141
def create_source
  case @source
  when :sudachi
    Sudachi.new
  end
end
format_availables(availables) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 65
def format_availables(availables)
  "[" + availables.join(", ") + "]"
end
format_defaults(key) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 69
def format_defaults(key)
  AVAILABLE_FORMATS.collect do |format|
    "#{format}: (#{@defaults[format][key]})"
  end
end
open_output() { |$stdout| ... } click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 130
def open_output(&block)
  case @output
  when "-"
    yield($stdout)
  when String
    File.open(@output, "w", &block)
  else
    yield(@output)
  end
end
parse_args(args, tag) click to toggle source
# File lib/groonga-synonym/command-line/generator.rb, line 75
def parse_args(args, tag)
  parser = OptionParser.new
  parser.on("--source=SOURCE",
            AVAILABLE_SOURCES,
            "Synonym source",
            format_availables(AVAILABLE_SOURCES),
            "(#{@source})") do |source|
    @source = source
  end
  parser.on("--format=FORMAT",
            AVAILABLE_FORMATS,
            "Output format",
            format_availables(AVAILABLE_FORMATS),
            "(#{@format})") do |format|
    @format = format
  end
  parser.on("--table=TABLE",
            "Synonyms table's name",
            *format_defaults(:table)) do |table|
    @table = table
  end
  parser.on("--term-column=COLUMN",
            "Term column's name",
            *format_defaults(:term_column)) do |column|
    @term_column = column
  end
  parser.on("--synonyms-column=COLUMN",
            "Synonyms column's name",
            *format_defaults(:synonyms_column)) do |column|
    @synonyms_column = column
  end
  parser.on("--no-synonyms-column-is-vector",
            "Synonyms column isn't a vector column",
            "This is only for 'groonga' source") do |boolean|
    @synonyms_column_is_vector = boolean
  end
  parser.on("--output=OUTPUT",
            "Output path",
            "'-' means the standard output",
            "(#{@output})") do |output|
    @output = output
  end
  parser.on("--version",
            "Show version and exit") do
    puts(VERSION)
    throw(tag, true)
  end
  parser.on("--help",
            "Show this message and exit") do
    puts(parser.help)
    throw(tag, true)
  end
  parser.parse!(args.dup)
end