at_coder_friends 0.3.1

data/config/.at_coder_friends.yml.sample

@@ -0,0 +1,2 @@
+user: <user>
+password: <password>

data/exe/at_coder_friends

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'at_coder_friends'
+
+ec = AtCoderFriends::CLI.new.run
+
+exit ec

data/lib/at_coder_friends.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'at_coder_friends/version'
+require 'at_coder_friends/errors'
+require 'at_coder_friends/path_util'
+require 'at_coder_friends/config_loader'
+require 'at_coder_friends/verifier'
+require 'at_coder_friends/test_runner'
+require 'at_coder_friends/sample_test_runner'
+require 'at_coder_friends/judge_test_runner'
+require 'at_coder_friends/problem'
+require 'at_coder_friends/scraping_agent'
+require 'at_coder_friends/format_parser'
+require 'at_coder_friends/ruby_generator'
+require 'at_coder_friends/cxx_generator'
+require 'at_coder_friends/emitter'
+require 'at_coder_friends/cli'

data/lib/at_coder_friends/cli.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module AtCoderFriends
+  # command line interface
+  class CLI
+    include PathUtil
+
+    EXITING_OPTIONS = %i[version].freeze
+    OPTION_BANNER =
+      <<~TEXT
+        Usage:
+          at_coder_friends setup    path/contest       # setup contest folder
+          at_coder_friends test-one path/contest/src   # run 1st test case
+          at_coder_friends test-all path/contest/src   # run all test cases
+          at_coder_friends submit   path/contest/src   # submit source code
+        Options:
+      TEXT
+    STATUS_SUCCESS  = 0
+    STATUS_ERROR    = 1
+
+    def run(args = ARGV)
+      parse_options!(args)
+      handle_exiting_option
+      raise ParamError, 'command or path is not specified.' if args.size < 2
+      @config = ConfigLoader.load_config(args[1])
+      exec_command(*args)
+      STATUS_SUCCESS
+    rescue AtCoderFriends::ParamError => e
+      warn @usage
+      warn "error: #{e.message}"
+      STATUS_ERROR
+    rescue AtCoderFriends::AppError => e
+      warn e.message
+      STATUS_ERROR
+    rescue SystemExit => e
+      e.status
+    end
+
+    def parse_options!(args)
+      op = OptionParser.new do |opts|
+        opts.banner = OPTION_BANNER
+        opts.on('-v', '--version', 'Display version.') do
+          @options[:version] = true
+        end
+      end
+      @usage = op.to_s
+      @options = {}
+      op.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      raise ParamError, e.message
+    end
+
+    def handle_exiting_option
+      return unless EXITING_OPTIONS.any? { |o| @options.key? o }
+      puts AtCoderFriends::VERSION if @options[:version]
+      exit STATUS_SUCCESS
+    end
+
+    def exec_command(command, path, id = nil)
+      case command
+      when 'setup'
+        setup(path)
+      when 'test-one'
+        test_one(path, id)
+      when 'test-all'
+        test_all(path)
+      when 'submit'
+        submit(path)
+      when 'judge-one'
+        judge_one(path, id)
+      when 'judge-all'
+        judge_all(path)
+      else
+        raise ParamError, "unknown command: #{command}"
+      end
+    end
+
+    def setup(path)
+      raise AppError, "#{path} is not empty." \
+        if Dir.exist?(path) && !Dir["#{path}/*"].empty?
+      agent = ScrapingAgent.new(contest_name(path), @config)
+      parser = FormatParser.new
+      rb_gen = RubyGenerator.new
+      cxx_gen = CxxGenerator.new
+      emitter = Emitter.new(path)
+      agent.fetch_all do |pbm|
+        parser.process(pbm)
+        rb_gen.process(pbm)
+        cxx_gen.process(pbm)
+        emitter.emit(pbm)
+      end
+    end
+
+    def test_one(path, id)
+      id ||= 1
+      SampleTestRunner.new(path).test_one(id)
+    end
+
+    def test_all(path)
+      SampleTestRunner.new(path).test_all
+      Verifier.new(path).verify
+    end
+
+    def submit(path)
+      vf = Verifier.new(path)
+      raise AppError, "#{vf.file} has not been tested." unless vf.verified?
+      ScrapingAgent.new(contest_name(path), @config).submit(path)
+      vf.unverify
+    end
+
+    def judge_one(path, id)
+      id ||= ''
+      JudgeTestRunner.new(path).judge_one(id)
+    end
+
+    def judge_all(path)
+      JudgeTestRunner.new(path).judge_all
+    end
+  end
+end

data/lib/at_coder_friends/config_loader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+
+module AtCoderFriends
+  # loads configuration file from the specified directory.
+  class ConfigLoader
+    DOTFILE = '.at_coder_friends.yml'
+
+    class << self
+      def load_config(target_dir)
+        path = find_file_upwards(DOTFILE, target_dir)
+        load_yaml(path)
+      end
+
+      def find_file_upwards(filename, start_dir)
+        Pathname.new(start_dir).expand_path.ascend do |dir|
+          file = dir + filename
+          return file.to_s if file.exist?
+        end
+        raise ConfigNotFoundError,
+              "Configuration file not found: #{start_dir}"
+      end
+
+      def load_yaml(path)
+        yaml = IO.read(path, encoding: Encoding::UTF_8)
+        YAML.safe_load(yaml, [], [], false, path)
+      rescue Errno::ENOENT
+        raise ConfigNotFoundError,
+              "Configuration file not found: #{path}"
+      end
+    end
+  end
+end

data/lib/at_coder_friends/cxx_generator.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  # generates C++ source code from definition
+  class CxxGenerator
+    # rubocop:disable Style/FormatStringToken
+    TEMPLATE = <<~TEXT
+      #include <cstdio>
+
+      using namespace std;
+
+      #define REP(i,n)   for(int i=0; i<(int)(n); i++)
+      #define FOR(i,b,e) for(int i=(b); i<=(int)(e); i++)
+
+      /*** CONSTS ***/
+
+      /*** DCLS ***/
+
+      void solve() {
+        int ans = 0;
+        printf("%d\\n", ans);
+      }
+
+      void input() {
+      /*** READS ***/
+      }
+
+      int main() {
+        input();
+        solve();
+        return 0;
+      }
+    TEXT
+    # rubocop:enable Style/FormatStringToken
+
+    SCANF_FMTS = [
+      'scanf("%<fmt>s", %<addr>s);',
+      'REP(i, %<sz1>s) scanf("%<fmt>s", %<addr>s);',
+      'REP(i, %<sz1>s) REP(j, %<sz2>s) scanf("%<fmt>s", %<addr>s);'
+    ].freeze
+
+    # rubocop:disable Style/FormatStringToken
+    FMT_FMTS = { number: '%d', string: '%s', char: '%s' }.freeze
+    # rubocop:enable Style/FormatStringToken
+
+    ADDR_FMTS = {
+      single: {
+        number: '&%<v>s',
+        string: '%<v>s'
+      },
+      harray: {
+        number: '%<v>s + i',
+        string: '%<v>s[i]',
+        char: '%<v>s'
+      },
+      varray: {
+        number: '%<v>s + i',
+        string: '%<v>s[i]'
+      },
+      matrix: {
+        number: '&%<v>s[i][j]',
+        string: '%<v>s[i][j]',
+        char: '%<v>s[i]'
+      }
+    }.freeze
+
+    def process(pbm)
+      src = generate(pbm.defs, pbm.desc)
+      pbm.add_src(:cxx, src)
+    end
+
+    def generate(defs, desc)
+      consts = gen_consts(desc)
+      dcls = gen_decls(defs)
+      reads = gen_reads(defs)
+      TEMPLATE
+        .sub('/*** CONSTS ***/', consts.join("\n"))
+        .sub('/*** DCLS ***/', dcls.join("\n"))
+        .sub('/*** READS ***/', reads.map { |s| '  ' + s }.join("\n"))
+    end
+
+    def gen_consts(desc)
+      desc
+        .gsub(/[,\\\(\)\{\}\|]/, '')
+        .gsub(/(≤|leq)/i, '≦')
+        .scan(/([\da-z_]+)\s*≦\s*(\d+)(?:\^(\d+))?/i)
+        .map do |v, sz, k|
+          sz = sz.to_i
+          sz **= k.to_i if k
+          "const int #{v.upcase}_MAX = #{sz};"
+        end
+    end
+
+    def gen_decls(defs)
+      defs.map { |inpdef| gen_decl(inpdef) }.flatten
+    end
+
+    def gen_decl(inpdef)
+      case inpdef.container
+      when :single
+        gen_single_decl(inpdef)
+      when :harray
+        gen_harray_decl(inpdef)
+      when :varray
+        gen_varray_decl(inpdef)
+      when :matrix
+        gen_matrix_decl(inpdef)
+      end
+    end
+
+    def gen_single_decl(inpdef)
+      names = inpdef.names
+      case inpdef.item
+      when :number
+        dcl = names.join(', ')
+        "int #{dcl};"
+      when :string
+        names.map { |v| "char #{v}[#{v.upcase}_MAX + 1];" }
+      end
+    end
+
+    def gen_harray_decl(inpdef)
+      v = inpdef.names[0]
+      sz = gen_arr_size(inpdef.size)[0]
+      case inpdef.item
+      when :number
+        "int #{v}[#{sz}];"
+      when :string
+        "char #{v}[#{sz}][#{v.upcase}_MAX + 1];"
+      when :char
+        "char #{v}[#{sz} + 1];"
+      end
+    end
+
+    def gen_varray_decl(inpdef)
+      names = inpdef.names
+      sz = gen_arr_size(inpdef.size)[0]
+      case inpdef.item
+      when :number
+        names.map { |v| "int #{v}[#{sz}];" }
+      when :string
+        names.map { |v| "char #{v}[#{sz}][#{v.upcase}_MAX + 1];" }
+      end
+    end
+
+    def gen_matrix_decl(inpdef)
+      v = inpdef.names[0]
+      sz1, sz2 = gen_arr_size(inpdef.size)
+      case inpdef.item
+      when :number
+        "int #{v}[#{sz1}][#{sz2}];"
+      when :string
+        "char #{v}[#{sz1}][#{sz2}][#{v.upcase}_MAX + 1];"
+      when :char
+        "char #{v}[#{sz1}][#{sz2} + 1];"
+      end
+    end
+
+    def gen_arr_size(szs)
+      szs.map { |sz| sz =~ /\D/ ? "#{sz.upcase}_MAX" : sz }
+    end
+
+    def gen_reads(defs)
+      defs.map { |inpdef| gen_read(inpdef) }.flatten
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def gen_read(inpdef)
+      dim = inpdef.size.size - (inpdef.item == :char ? 1 : 0)
+      scanf = SCANF_FMTS[dim]
+      sz1, sz2 = inpdef.size
+      fmt = FMT_FMTS[inpdef.item] * inpdef.names.size
+      addr_fmt = ADDR_FMTS[inpdef.container][inpdef.item]
+      addr = inpdef.names.map { |v| format(addr_fmt, v: v) }.join(', ')
+      format(scanf, sz1: sz1, sz2: sz2, fmt: fmt, addr: addr)
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/at_coder_friends/emitter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module AtCoderFriends
+  # emits source skeletons and sample input/output(s)
+  # of a problem to the specified directory.
+  class Emitter
+    include PathUtil
+
+    def initialize(dir)
+      @src_dir = dir
+      @smp_dir = smp_dir(dir)
+    end
+
+    def emit(pbm)
+      pbm.smps.each { |smp| emit_sample(pbm, smp) }
+      pbm.srcs.each { |src| emit_source(pbm, src) }
+    end
+
+    def emit_sample(pbm, smp)
+      makedirs_unless @smp_dir
+      smp_file = format(
+        '%<q>s_%<n>03d.%<ext>s', q: pbm.q, n: smp.no, ext: smp.ext
+      )
+      smp_path = File.join(@smp_dir, smp_file)
+      File.write(smp_path, smp.txt)
+      puts smp_file
+    end
+
+    def emit_source(pbm, src)
+      makedirs_unless @src_dir
+      src_file = format('%<q>s.%<ext>s', q: pbm.q, ext: src.ext)
+      src_path = File.join(@src_dir, src_file)
+      File.write(src_path, src.txt)
+      puts src_file
+    end
+
+    def makedirs_unless(dir)
+      FileUtils.makedirs(dir) unless Dir.exist?(dir)
+    end
+  end
+end

data/lib/at_coder_friends/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  class AppError < StandardError; end
+  class ParamError < AppError; end
+  class ConfigNotFoundError < AppError; end
+end

data/lib/at_coder_friends/format_parser.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  # Iterates through elements of an array
+  class Iterator
+    def initialize(array)
+      @array = array
+      @i = 0
+    end
+
+    def next?
+      @i < @array.size
+    end
+
+    def next
+      ret = @array[@i]
+      @i += 1
+      ret
+    end
+  end
+
+  # parses input data format and generates input definitons
+  class FormatParser
+    PARSERS = [
+      {
+        container: :harray,
+        item: :number,
+        pat: /^(?<v>[a-z]+)[01](\s+\k<v>.)*(\s+\.+)?(\s+\k<v>.)+$/i,
+        names: ->(m) { [m[:v]] },
+        pat2: ->(_) { nil },
+        size: ->(f) { [f[-1]] }
+      },
+      {
+        container: :harray,
+        item: :char,
+        pat: /^(?<v>[a-z]+)[01](\k<v>.)*(\s*\.+\s*)?(\k<v>.)+$/i,
+        names: ->(m) { [m[:v]] },
+        pat2: ->(_) { nil },
+        size: ->(f) { [f[-1]] }
+      },
+      {
+        container: :matrix,
+        item: :number,
+        pat: /^(?<v>[a-z]+)[01][01](\s+\k<v>..)*(\s+\.+)?(\s+\k<v>..)+$/i,
+        names: ->(m) { [m[:v]] },
+        pat2: ->(v) { /(^#{v}..(\s+#{v}..)*(\s+\.+)?(\s+#{v}..)+|\.+)$/ },
+        size: ->(f) { f[-2..-1].chars.to_a }
+      },
+      {
+        container: :matrix,
+        item: :char,
+        pat: /^(?<v>[a-z]+)[01][01](\k<v>..)*(\s*\.+\s*)?(\k<v>..)+$/i,
+        names: ->(m) { [m[:v]] },
+        pat2: ->(v) { /(^#{v}..(#{v}..)*(\s*\.+\s*)?(#{v}..)+|\.+)$/ },
+        size: ->(f) { f[-2..-1].chars.to_a }
+      },
+      {
+        container: :varray,
+        item: :number,
+        pat: /^[a-z]+(?<i>[0-9])(\s+[a-z]+\k<i>)*$/i,
+        names: ->(m) { m[0].split.map { |w| w[0..-2] } },
+        pat2: lambda { |vs|
+          pat = vs.map { |v| v + '.+' }.join('\s+')
+          /^(#{pat}|\.+)$/
+        },
+        size: ->(f) { /(?<sz>\d+)$/ =~ f ? [sz] : [f[-1]] }
+      },
+      {
+        container: :single,
+        item: :number,
+        pat: /^[a-z]+(\s+[a-z]+)*$/i,
+        names: ->(m) { m[0].split },
+        pat2: ->(_) { nil },
+        size: ->(_) { [] }
+      }
+    ].freeze
+
+    def process(pbm)
+      defs = parse(pbm.fmt, pbm.smps)
+      pbm.defs = defs
+    end
+
+    def parse(fmt, smps)
+      lines = split_trim(fmt)
+      defs = parse_fmt(lines)
+      smpx = max_smp(smps)
+      return defs unless smpx
+      match_smp!(defs, smpx)
+    end
+
+    def split_trim(fmt)
+      fmt
+        .gsub(/[+-]1/, '') # N-1, N+1 -> N
+        .gsub(%r{[-/　]}, ' ') # a-b, a/b -> a b
+        .gsub(/\{.*?\}/) { |w| w.delete(' ') } # {1, 1} -> {1,1} shortest match
+        .gsub(/[_,'\\\(\)\{\}]/, '')
+        .gsub(/[:：…‥]+/, '..')
+        .gsub(/^[\.\s]+$/, '..')
+        .split("\n")
+        .map(&:strip)
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def parse_fmt(lines)
+      it = Iterator.new(lines + ['']) # sentinel
+      prv = nil
+      cur = it.next
+      Enumerator.new do |y|
+        loop do
+          unless (parser = PARSERS.find { |ps| ps[:pat] =~ cur })
+            puts "unknown format: #{cur}" unless cur.empty?
+            (cur = it.next) ? next : break
+          end
+          container, item = parser.values_at(:container, :item)
+          m = parser[:pat].match(cur)
+          names = parser[:names].call(m)
+          pat2 = parser[:pat2].call(names)
+          loop do
+            prv = cur
+            cur = it.next
+            break unless pat2 && pat2 =~ cur
+          end
+          size = parser[:size].call(prv)
+          y << InputDef.new(container, item, names, size)
+        end
+      end.to_a
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def max_smp(smps)
+      smps
+        .select { |smp| smp.ext == :in }
+        .max_by { |smp| smp.txt.size }
+        &.txt
+    end
+
+    def match_smp!(inpdefs, smp)
+      lines = smp.split("\n")
+      inpdefs.each_with_index do |inpdef, i|
+        break if i > lines.size
+        next if inpdef.item != :number
+        inpdef.item = :string if lines[i].split[0] =~ /[^\-0-9]/
+        break if %i[varray matrix].include?(inpdef.container)
+      end
+      inpdefs
+    end
+  end
+end