at_coder_friends 0.6.2 → 0.6.7

data/lib/at_coder_friends/config_loader.rb

@@ -11,20 +11,28 @@ module AtCoderFriends
     DEFAULT_FILE = File.join(ACF_HOME, 'config', 'default.yml')
 
     class << self
+      def dotfile
+        DOTFILE
+      end
+
+      def default_file
+        DEFAULT_FILE
+      end
+
       def load_config(ctx)
         path = config_file_for(ctx.path)
         config = load_yaml(path)
-        return config if path == DEFAULT_FILE
+        return config if path == default_file
 
         merge_with_default(config)
       end
 
       def config_file_for(target_dir)
-        find_project_dotfile(target_dir) || DEFAULT_FILE
+        find_project_dotfile(target_dir) || default_file
       end
 
       def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir)
+        find_file_upwards(dotfile, target_dir)
       end
 
       def find_file_upwards(filename, start_dir)

data/lib/at_coder_friends/context.rb

@@ -7,11 +7,15 @@ module AtCoderFriends
   # - configuration
   # - application modules
   class Context
-    attr_reader :options, :path
+    attr_reader :options, :path_info
 
     def initialize(options, path)
       @options = options
-      @path = File.expand_path(path)
+      @path_info = PathInfo.new(File.expand_path(path))
+    end
+
+    def path
+      path_info.path
     end
 
     def config
@@ -26,6 +30,10 @@ module AtCoderFriends
       @generator ||= Generator::Main.new(self)
     end
 
+    def emitter
+      @emitter ||= Emitter.new(self)
+    end
+
     def sample_test_runner
       @sample_test_runner ||= TestRunner::Sample.new(self)
     end
@@ -38,10 +46,6 @@ module AtCoderFriends
       @verifier ||= Verifier.new(self)
     end
 
-    def emitter
-      @emitter ||= Emitter.new(self)
-    end
-
     def post_process
       @scraping_agent&.save_session
     end

data/lib/at_coder_friends/emitter.rb

@@ -9,8 +9,8 @@ module AtCoderFriends
     include PathUtil
 
     def initialize(ctx)
-      @src_dir = ctx.path
-      @smp_dir = smp_dir(@src_dir)
+      @src_dir = ctx.path_info.src_dir
+      @smp_dir = ctx.path_info.smp_dir
     end
 
     def emit(pbm)

data/lib/at_coder_friends/generator/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module AtCoderFriends
+  module Generator
+    Attributes = Struct.new(:file_ext, :default_template)
+
+    # common behavior of generators
+    class Base
+      attr_reader :cfg, :pbm
+
+      def initialize(cfg = nil)
+        @cfg = cfg || {}
+      end
+
+      def process(pbm)
+        pbm.add_src(attrs.file_ext, generate(pbm))
+      end
+
+      def generate(pbm)
+        @pbm = pbm
+        src = File.read(select_template)
+        src = ERB.new(src, safe_level = nil, trim_mode = '-').result(binding)
+        src = render(src) if respond_to?(:render)
+        src
+      end
+
+      def select_template
+        cfg['default_template'] || attrs.default_template
+      end
+
+      def embed_lines(src, pat, lines)
+        re = Regexp.escape(pat)
+        src.gsub(
+          /^(.*)#{re}(.*)$\n/,
+          lines.compact.map { |s| "\\1#{s}\\2\n" }.join
+        )
+      end
+    end
+  end
+end

data/lib/at_coder_friends/generator/cxx_builtin.rb

@@ -2,96 +2,8 @@
 
 module AtCoderFriends
   module Generator
-    module CxxBuiltinConstants
-      ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
-      TMPL_DIR = File.join(ACF_HOME, 'templates')
-      DEFAULT_TMPL = File.join(TMPL_DIR, 'cxx_builtin_default.cxx')
-      INTERACTIVE_TMPL = File.join(TMPL_DIR, 'cxx_builtin_interactive.cxx')
-      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
-      FMT_FMTS = { number: '%d', string: '%s', char: '%s' }.freeze
-      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
-      DEFAULT_OUTPUT = <<~TEXT
-        int ans = 0;
-        printf("%d\\n", ans);
-      TEXT
-      BINARY_OUTPUT_FMT = <<~TEXT
-        bool cond = false;
-        puts(cond ? "%s" : "%s");
-      TEXT
-    end
-
-    # generates C++ source from problem description
-    class CxxBuiltin
-      include CxxBuiltinConstants
-
-      attr_reader :cfg, :pbm
-
-      def initialize(cfg = nil)
-        @cfg = cfg || {}
-      end
-
-      def process(pbm)
-        src = generate(pbm)
-        pbm.add_src(:cxx, src)
-      end
-
-      def generate(pbm)
-        @pbm = pbm
-        src = File.read(select_template)
-        src = embed_lines(src, '/*** URL ***/', [pbm.url])
-        src = embed_lines(src, '/*** CONSTS ***/', gen_consts)
-        src = embed_lines(src, '/*** DCLS ***/', gen_decls)
-        src = embed_lines(src, '/*** INPUTS ***/', gen_inputs)
-        embed_lines(src, '/*** OUTPUT ***/', gen_output.split("\n"))
-      end
-
-      def embed_lines(src, pat, lines)
-        re = Regexp.escape(pat)
-        src.gsub(
-          /^(.*)#{re}(.*)$/,
-          lines.map { |s| '\1' + s + '\2' }.join("\n")
-        )
-      end
-
-      def select_template(interactive = pbm.options.interactive)
-        interactive ? interactive_template : default_template
-      end
-
-      def default_template
-        cfg['default_template'] || DEFAULT_TMPL
-      end
-
-      def interactive_template
-        cfg['interactive_template'] || INTERACTIVE_TMPL
-      end
-
-      def gen_consts(constants = pbm.constants)
-        constants.map { |c| gen_const(c) }
-      end
-
+    # generates C++ constants
+    module CxxBuiltinConstGen
       def gen_const(c)
         v = cnv_const_value(c.value)
         if c.type == :max
@@ -107,98 +19,239 @@ module AtCoderFriends
           .sub(/\b2\^/, '1<<')
           .gsub(',', "'")
       end
+    end
 
-      def gen_decls(inpdefs = pbm.formats)
-        inpdefs.map { |inpdef| gen_decl(inpdef) }.flatten
-      end
-
+    # generates C++ variable declarations
+    module CxxBuiltinDeclGen
+      TYPE_TBL = {
+        number: 'int',
+        decimal: 'double',
+        string: 'char',
+        char: 'char'
+      }.tap { |h| h.default = 'int' }
       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)
+        if inpdef.components
+          inpdef.components.map { |cmp| gen_decl(cmp) }
+        else
+          case inpdef.container
+          when :single
+            gen_single_decl(inpdef)
+          when :harray
+            gen_harray_decl(inpdef)
+          when :varray
+            gen_varray_decl(inpdef)
+          when :matrix, :vmatrix, :hmatrix
+            gen_matrix_decl(inpdef)
+          end
         end
       end
 
       def gen_single_decl(inpdef)
-        names = inpdef.names
-        case inpdef.item
-        when :number
+        names, cols = inpdef.vars.transpose
+        if cols.uniq.size == 1 && cols[0] != :string
+          type = TYPE_TBL[cols[0]]
           dcl = names.join(', ')
-          "int #{dcl};"
-        when :string
-          names.map { |v| "char #{v}[#{v.upcase}_MAX + 1];" }
+          "#{type} #{dcl};"
+        else
+          inpdef.vars.map do |v, item|
+            type = TYPE_TBL[item]
+            dcl = v
+            dcl += "[#{v.upcase}_MAX + 1]" if item == :string
+            "#{type} #{dcl};"
+          end
         end
       end
 
       def gen_harray_decl(inpdef)
+        type = TYPE_TBL[inpdef.item]
         v = inpdef.names[0]
         sz = gen_arr_size(inpdef.size)[0]
         case inpdef.item
-        when :number
-          "int #{v}[#{sz}];"
+        when :number, :decimal
+          "#{type} #{v}[#{sz}];"
         when :string
-          "char #{v}[#{sz}][#{v.upcase}_MAX + 1];"
+          "#{type} #{v}[#{sz}][#{v.upcase}_MAX + 1];"
         when :char
-          "char #{v}[#{sz} + 1];"
+          "#{type} #{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];" }
+        inpdef.vars.map do |v, item|
+          type = TYPE_TBL[item]
+          dcl = "#{v}[#{sz}]"
+          dcl += "[#{v.upcase}_MAX + 1]" if item == :string
+          "#{type} #{dcl};"
         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];"
+        inpdef.vars.map do |v, item|
+          type = TYPE_TBL[item]
+          dcl = "#{v}[#{sz1}]"
+          dcl += item == :char ? "[#{sz2} + 1]" : "[#{sz2}]"
+          dcl += "[#{v.upcase}_MAX + 1]" if item == :string
+          "#{type} #{dcl};"
         end
       end
 
       def gen_arr_size(szs)
         szs.map { |sz| sz.gsub(/([a-z][a-z0-9_]*)/i, '\1_MAX').upcase }
       end
+    end
 
-      def gen_inputs(inpdefs = pbm.formats)
-        inpdefs.map { |inpdef| gen_input(inpdef) }.flatten
-      end
+    # generates C++ input source
+    module CxxBuiltinInputGen
+      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
+      SCANF_FMTS_CMB = {
+        varray_matrix:
+          [
+            <<~TEXT,
+              REP(i, %<sz1>s) {
+                scanf("%<fmt1>s", %<addr1>s);
+                scanf("%<fmt2>s", %<addr2>s);
+              }
+            TEXT
+            <<~TEXT
+              REP(i, %<sz1>s) {
+                scanf("%<fmt1>s", %<addr1>s);
+                REP(j, %<sz2>s[i]) scanf("%<fmt2>s", %<addr2>s);
+              }
+            TEXT
+          ],
+        matrix_varray:
+          [
+            <<~TEXT,
+              REP(i, %<sz1>s) {
+                scanf("%<fmt1>s", %<addr1>s);
+                scanf("%<fmt2>s", %<addr2>s);
+              }
+            TEXT
+            <<~TEXT
+              REP(i, %<sz1>s) {
+                REP(j, %<sz2>s) scanf("%<fmt1>s", %<addr1>s);
+                scanf("%<fmt2>s", %<addr2>s);
+              }
+            TEXT
+          ]
+      }.tap { |h| h.default = h[:varray_matrix] }
+      FMT_FMTS = {
+        number: '%d',
+        decimal: '%lf',
+        string: '%s',
+        char: '%s'
+      }.tap { |h| h.default = h[:number] }
+      SINGLE_ADDR_FMTS = {
+        number: '&%<v>s',
+        decimal: '&%<v>s',
+        string: '%<v>s'
+      }.tap { |h| h.default = h[:number] }
+      ARRAY_ADDR_FMTS = {
+        number: '%<v>s + i',
+        decimal: '%<v>s + i',
+        string: '%<v>s[i]',
+        char: '%<v>s'
+      }.tap { |h| h.default = h[:number] }
+      MATRIX_ADDR_FMTS = {
+        number: '&%<v>s[i][j]',
+        decimal: '&%<v>s[i][j]',
+        string: '%<v>s[i][j]',
+        char: '%<v>s[i]'
+      }.tap { |h| h.default = h[:number] }
+      ADDR_FMTS = {
+        single: SINGLE_ADDR_FMTS,
+        harray: ARRAY_ADDR_FMTS,
+        varray: ARRAY_ADDR_FMTS,
+        matrix: MATRIX_ADDR_FMTS,
+        vmatrix: MATRIX_ADDR_FMTS,
+        hmatrix: MATRIX_ADDR_FMTS
+      }.tap { |h| h.default = h[:single] }
 
-      # rubocop:disable Metrics/AbcSize
       def gen_input(inpdef)
-        dim = inpdef.size.size - (inpdef.item == :char ? 1 : 0)
-        scanf = SCANF_FMTS[dim]
+        if inpdef.components
+          gen_cmb_input(inpdef)
+        else
+          gen_plain_input(inpdef)
+        end
+      end
+
+      def gen_plain_input(inpdef)
+        scanf = SCANF_FMTS[inpdef.size.size - (inpdef.item == :char ? 1 : 0)]
         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(', ')
+        fmt, addr = scanf_params(inpdef)
         format(scanf, sz1: sz1, sz2: sz2, fmt: fmt, addr: addr)
       end
-      # rubocop:enable Metrics/AbcSize
 
-      def gen_output(vs = pbm.options.binary_values)
-        if vs
-          format(BINARY_OUTPUT_FMT, *vs)
-        else
-          DEFAULT_OUTPUT
-        end
+      def gen_cmb_input(inpdef)
+        scanf = SCANF_FMTS_CMB.dig(
+          inpdef.container, inpdef.item == :char ? 0 : 1
+        )
+        sz1 = inpdef.size[0]
+        sz2 = inpdef.size[1].split('_')[0]
+        fmt1, addr1, fmt2, addr2 =
+          inpdef.components.map { |cmp| scanf_params(cmp) }.flatten
+        format(
+          scanf,
+          sz1: sz1, sz2: sz2,
+          fmt1: fmt1, addr1: addr1,
+          fmt2: fmt2, addr2: addr2
+        ).split("\n")
+      end
+
+      def scanf_params(inpdef)
+        [scanf_fmt(inpdef), scanf_addr(inpdef)]
+      end
+
+      def scanf_fmt(inpdef)
+        inpdef.vars.map { |(_v, item)| FMT_FMTS[item] }.join
+      end
+
+      def scanf_addr(inpdef)
+        inpdef.vars.map do |(v, item)|
+          addr_fmt = ADDR_FMTS.dig(inpdef.container, item)
+          format(addr_fmt, v: v)
+        end.join(', ')
+      end
+    end
+
+    # generates C++ source from problem description
+    class CxxBuiltin < Base
+      include CxxBuiltinConstGen
+      include CxxBuiltinDeclGen
+      include CxxBuiltinInputGen
+
+      ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
+      TMPL_DIR = File.join(ACF_HOME, 'templates')
+      DEFAULT_TMPL = File.join(TMPL_DIR, 'cxx_builtin.cxx.erb')
+      ATTRS = Attributes.new(:cxx, DEFAULT_TMPL)
+
+      def attrs
+        ATTRS
+      end
+
+      def render(src)
+        src = embed_lines(src, '/*** CONSTS ***/', gen_consts)
+        src = embed_lines(src, '/*** DCLS ***/', gen_decls)
+        src = embed_lines(src, '/*** INPUTS ***/', gen_inputs)
+        src
+      end
+
+      def gen_consts(constants = pbm.constants)
+        constants.map { |c| gen_const(c) }
+      end
+
+      def gen_decls(inpdefs = pbm.formats)
+        inpdefs.map { |inpdef| gen_decl(inpdef) }.flatten
+      end
+
+      def gen_inputs(inpdefs = pbm.formats)
+        inpdefs.map { |inpdef| gen_input(inpdef) }.flatten
       end
     end
   end