at_coder_friends 0.6.9 → 0.7.0

data/lib/at_coder_friends/generator/cxx_builtin.rb

@@ -2,256 +2,25 @@
 
 module AtCoderFriends
   module Generator
-    # generates C++ constants
-    module CxxBuiltinConstGen
-      def gen_const(c)
-        v = cnv_const_value(c.value)
-        if c.type == :max
-          "const int #{c.name.upcase}_MAX = #{v};"
-        else
-          "const int MOD = #{v};"
-        end
-      end
-
-      def cnv_const_value(v)
-        v
-          .sub(/\b10\^/, '1e')
-          .sub(/\b2\^/, '1<<')
-          .gsub(',', "'")
-      end
-    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)
-        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, cols = inpdef.vars.transpose
-        if cols.uniq.size == 1 && cols[0] != :string
-          type = TYPE_TBL[cols[0]]
-          dcl = names.join(', ')
-          "#{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, :decimal
-          "#{type} #{v}[#{sz}];"
-        when :string
-          "#{type} #{v}[#{sz}][#{v.upcase}_MAX + 1];"
-        when :char
-          "#{type} #{v}[#{sz} + 1];"
-        end
-      end
-
-      def gen_varray_decl(inpdef)
-        sz = gen_arr_size(inpdef.size)[0]
-        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)
-        sz1, sz2 = gen_arr_size(inpdef.size)
-        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
-
-    # 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] }
-
-      def gen_input(inpdef)
-        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, addr = scanf_params(inpdef)
-        format(scanf, sz1: sz1, sz2: sz2, fmt: fmt, addr: addr)
-      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)
+    class CxxBuiltin < CBuiltin
+      TEMPLATE = File.join(TMPL_DIR, 'cxx_builtin.cxx.erb')
+      ATTRS = Attributes.new(:cxx, TEMPLATE, FRAGMENTS)
 
       def attrs
         ATTRS
       end
 
+      def gen_const(c)
+        ConstFragment.new(c, fragments['cxx_constant']).generate
+      end
+
+      # deprecated, use ERB syntax
       def render(src)
         src = embed_lines(src, '/*** CONSTS ***/', gen_consts)
         src = embed_lines(src, '/*** DCLS ***/', gen_decls)
         embed_lines(src, '/*** INPUTS ***/', gen_inputs)
       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
 end

data/lib/at_coder_friends/generator/fragment.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module AtCoderFriends
+  module Generator
+    # base class for code fragment generator
+    class FragmentBase
+      attr_reader :templates
+
+      def initialize(obj, templates)
+        @obj = obj
+        @templates = templates
+      end
+
+      def render(*keys)
+        keys = keys.map(&:to_s)
+        template = templates.dig(*keys) || (raise AppError, "fragment key #{keys} not found")
+
+        return ERB.new(template, trim_mode: '-').result(binding) if template.is_a?(String)
+
+        if template.is_a?(Hash)
+          sub_key_props = template['__key'] || (raise AppError, "'__key' not found in fragment hash #{keys}")
+          sub_keys = sub_key_props.map { |k| send(k) }
+          return render(*keys, *sub_keys)
+        end
+
+        raise AppError, "can't render fragment #{keys}"
+      end
+
+      # delegate method calls to obj
+      def method_missing(name, *args, &block)
+        if @obj.respond_to?(name)
+          @obj.send(name, *args, &block)
+        elsif templates.key?(name.to_s)
+          render(name)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @obj.respond_to?(name, include_private) ||
+          templates.key?(name.to_s) ||
+          super
+      end
+
+      def to_s
+        @obj.to_s
+      end
+    end
+
+    # base class for constant declaration generator
+    class ConstFragment < FragmentBase
+      def generate
+        render(type)
+      end
+    end
+
+    # base class for variable declaration generator
+    class InputFormatFragment < FragmentBase
+      def generate
+        render(:main)
+      end
+
+      def vs
+        names
+      end
+
+      def v
+        vs[0]
+      end
+
+      def sz1
+        size[0]
+      end
+      alias sz sz1
+
+      def sz2
+        size[1]
+      end
+
+      def delims
+        delim.chars
+      end
+
+      def vars
+        @vars ||= super.map do |v, item|
+          var = Problem::InputFormat.new(
+            container: container,
+            names: [v],
+            item: item,
+            size: size
+          )
+          self.class.new(var, templates)
+        end
+      end
+
+      def components
+        @components ||= super&.map do |cmp|
+          self.class.new(cmp, templates)
+        end
+      end
+    end
+  end
+end

data/lib/at_coder_friends/generator/main.rb

@@ -18,26 +18,34 @@ module AtCoderFriends
           gen_obj.process(pbm)
         rescue StandardError => e
           puts "an error occurred in generator:#{gen_name}."
-          puts e.to_s
+          puts e
           puts e.backtrace
         end
       end
 
       def load_obj(gen_name)
         @cache[gen_name] ||= begin
-          gen_class = load_class(gen_name)
+          cls_name = gen_name.split('_')[0]
+          gen_class = load_class(cls_name)
           gen_cnf = config_for(gen_name)
           gen_class.new(gen_cnf)
         end
       end
 
       def load_class(gen_name)
-        unless AtCoderFriends::Generator.const_defined?(gen_name)
-          require "at_coder_friends/generator/#{to_snake(gen_name)}"
-        end
+        snake_gen_name = to_snake(gen_name)
+        require "at_coder_friends/generator/#{snake_gen_name}" unless AtCoderFriends::Generator.const_defined?(gen_name)
         AtCoderFriends::Generator.const_get(gen_name)
       rescue LoadError
-        raise AppError, "plugin load error : generator #{gen_name} not found."
+        raise AppError, <<~MSG
+          Error: Failed to load plugin.
+          The '#{gen_name}' plugin could not be found. To use this plugin, please install the required gem by following these steps:
+
+          1. Open a terminal or command prompt.
+          2. Run the following command:
+             gem install at_coder_friends-generator-#{snake_gen_name}
+          3. Once the above command completes, please run the program again.
+        MSG
       end
 
       def config_for(gen_name)

data/lib/at_coder_friends/generator/ruby_builtin.rb

@@ -4,181 +4,29 @@ module AtCoderFriends
   module Generator
     # generates Ruby source from problem description
     class RubyBuiltin < Base
+      include ConstFragmentMixin
+      include DeclFragmentMixin
+
       ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
       TMPL_DIR = File.join(ACF_HOME, 'templates')
-      DEFAULT_TMPL = File.join(TMPL_DIR, 'ruby_builtin.rb.erb')
-      ATTRS = Attributes.new(:rb, DEFAULT_TMPL)
+      TEMPLATE = File.join(TMPL_DIR, 'ruby_builtin.rb.erb')
+      FRAGMENTS = File.realpath(File.join(TMPL_DIR, 'ruby_builtin_fragments.yml'))
+      ATTRS = Attributes.new(:rb, TEMPLATE, FRAGMENTS)
 
       def attrs
         ATTRS
       end
 
-      def render(src)
-        src = embed_lines(src, '### CONSTS ###', gen_consts)
-        embed_lines(src, '### DCLS ###', gen_decls)
-      end
-
-      def gen_consts(constants = pbm.constants)
-        constants
+      def gen_consts
+        pbm.constants
           .select { |c| c.type == :mod }
-          .map { |c| gen_mod(c) }
-      end
-
-      def gen_mod(c)
-        v = c.value.gsub('^', '**').gsub(',', '_')
-        "MOD = #{v}"
-      end
-
-      def gen_decls(inpdefs = pbm.formats)
-        inpdefs.map { |inpdef| gen_decl(inpdef) }.flatten
+          .map { |c| gen_const(c) }
       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)
-        when :varray_matrix, :matrix_varray
-          gen_cmb_decl(inpdef)
-        when :vmatrix
-          gen_vmatrix_decl(inpdef)
-        when :hmatrix
-          gen_hmatrix_decl(inpdef)
-        end
-      end
-
-      def gen_single_decl(inpdef)
-        names = inpdef.names
-        dcl = names.join(', ')
-        expr = gen_expr(inpdef, names.size > 1)
-        "#{dcl} = #{expr}"
-      end
-
-      def gen_harray_decl(inpdef)
-        v = inpdef.names[0]
-        dcl = "#{v}s"
-        expr = gen_expr(inpdef, true)
-        "#{dcl} = #{expr}"
-      end
-
-      def gen_varray_decl(inpdef)
-        if inpdef.names.size == 1
-          gen_varray_1_decl(inpdef)
-        else
-          gen_varray_n_decl(inpdef)
-        end
-      end
-
-      def gen_varray_1_decl(inpdef)
-        v = inpdef.names[0]
-        sz = inpdef.size[0]
-        dcl = "#{v}s"
-        expr = gen_expr(inpdef, false)
-        "#{dcl} = Array.new(#{sz}) { #{expr} }"
-      end
-
-      def gen_varray_n_decl(inpdef)
-        names = inpdef.names
-        sz = inpdef.size[0]
-        dcl = names.map { |v| "#{v}s[i]" }.join(', ')
-        expr = gen_expr(inpdef, true)
-        ret = []
-        ret += names.map { |v| "#{v}s = Array.new(#{sz})" }
-        ret << "#{sz}.times do |i|"
-        ret << "  #{dcl} = #{expr}"
-        ret << 'end'
-        ret
-      end
-
-      def gen_matrix_decl(inpdef)
-        v = inpdef.names[0]
-        sz = inpdef.size[0]
-        decl = "#{v}ss"
-        expr = gen_expr(inpdef, true)
-        "#{decl} = Array.new(#{sz}) { #{expr} }"
-      end
-
-      def gen_cmb_decl(inpdef)
-        mx = inpdef.container == :varray_matrix ? -1 : 0
-        vs = inpdef.names.map { |v| "#{v}s" }
-        vs[mx] += 's'
-        sz = inpdef.size[0]
-        dcls = vs.map { |v| "#{v}[i]" }
-        dcls[mx] = "*#{dcls[mx]}" unless inpdef.item == :char
-        dcl = dcls.join(', ')
-        expr = gen_cmb_expr(inpdef)
-        ret = []
-        ret += vs.map { |v| "#{v} = Array.new(#{sz})" }
-        ret << "#{sz}.times do |i|"
-        ret << "  #{dcl} = #{expr}"
-        ret << 'end'
-        ret
-      end
-
-      def gen_vmatrix_decl(inpdef)
-        names = inpdef.names
-        sz1, sz2 = inpdef.size
-        dcl = names.map { |v| "#{v}ss[i][j]" }.join(', ')
-        expr = gen_expr(inpdef, true)
-        ret = []
-        ret += names.map do |v|
-          "#{v}ss = Array.new(#{sz1}) { Array.new(#{sz2}) }"
-        end
-        ret << "#{sz1}.times do |i|"
-        ret << "  #{sz2}.times do |j|"
-        ret << "    #{dcl} = #{expr}"
-        ret << '  end'
-        ret << 'end'
-        ret
-      end
-
-      def gen_hmatrix_decl(inpdef)
-        names = inpdef.names
-        sz = inpdef.size[0]
-        dcl = names.map { |v| "#{v}ss[i]" }.join(', ')
-        expr = gen_expr(inpdef, true)
-        ret = []
-        ret += names.map { |v| "#{v}ss = Array.new(#{sz})" }
-        ret << "#{sz}.times do |i|"
-        ret << "  #{dcl} = #{expr}.each_slice(#{names.size}).to_a.transpose"
-        ret << 'end'
-        ret
-      end
-
-      def gen_expr(inpdef, split)
-        read = gen_read(inpdef.delim)
-        case inpdef.item
-        when :number
-          split ? "#{read}.split.map(&:to_i)" : "#{read}.to_i"
-        when :decimal
-          split ? "#{read}.split.map(&:to_f)" : "#{read}.to_f"
-        when :string
-          split ? "#{read}.chomp.split" : "#{read}.chomp"
-        when :char
-          'gets.chomp'
-        end
-      end
-
-      def gen_cmb_expr(inpdef)
-        read = gen_read(inpdef.delim)
-        case inpdef.item
-        when :number
-          "#{read}.split.map(&:to_i)"
-        when :decimal
-          "#{read}.split.map(&:to_f)"
-        when :string, :char
-          "#{read}.chomp.split"
-        end
-      end
-
-      def gen_read(delim)
-        sub = delim.chars.map { |d| ".gsub('#{d}', ' ')" }.join
-        "gets#{sub}"
+      # deprecated, use ERB syntax
+      def render(src)
+        src = embed_lines(src, '### CONSTS ###', gen_consts)
+        embed_lines(src, '### DCLS ###', gen_decls)
       end
     end
   end

data/lib/at_coder_friends/parser/binary.rb

@@ -8,9 +8,7 @@ module AtCoderFriends
 
       def process(pbm)
         vs = exp_values(pbm)
-        return unless vs.size == 2
-        return if vs.any? { |v| v.include?("\n") }
-        return if vs.any? { |v| v =~ /\A[0-9\s]*\z/ }
+        return unless binary_values?(vs)
 
         out_fmt = output_format(pbm)
         re1, re2 = vs.map { |v| Regexp.escape(v) }
@@ -32,6 +30,14 @@ module AtCoderFriends
           .uniq
       end
 
+      def binary_values?(vs)
+        return false unless vs.size == 2
+        return false if vs.any? { |v| v.include?("\n") }
+        return false if vs.any? { |v| v =~ /\A[0-9\s]*\z/ }
+
+        true
+      end
+
       def output_format(pbm)
         pbm.sections[Problem::SECTION_OUT_FMT]&.content || ''
       end

data/lib/at_coder_friends/parser/constraints.rb

@@ -34,14 +34,14 @@ module AtCoderFriends
 
       def parse(str)
         str = normalize_content(str)
-        str
-          .scan(MAX_PATTERN)
-          .map(&:compact)
-          .map { |k, v| [normalize_names(k), normalize_value(v)] }
-          .select { |_, v| v && !v.empty? }
-          .flat_map { |ks, v| ks.map { |k| [k, v] } }
-          .uniq
-          .map { |k, v| Problem::Constant.new(k, :max, v) }
+        pats = str.scan(MAX_PATTERN).map(&:compact)
+        pairs = pats.each_with_object([]) do |(k, v), result|
+          value = normalize_value(v)
+          next unless value && !value.empty?
+
+          normalize_names(k).each { |name| result << [name, value] }
+        end
+        pairs.uniq.map { |k, v| Problem::Constant.new(k, :max, v) }
       end
 
       def normalize_content(s)

data/lib/at_coder_friends/parser/input_format.rb

@@ -144,7 +144,7 @@ module AtCoderFriends
         sz = str.split('_')
         return sz if sz.size == 2
 
-        [str[0] || '_', str[1..-1] || '_']
+        [str[0] || '_', str[1..] || '_']
       end
     end
 
@@ -343,7 +343,7 @@ module AtCoderFriends
         gen_pat2:
           lambda { |vs|
             m = vs[0]
-            ws = vs[1..-1].map { |v| v + RE_IX.source }.join('\s+')
+            ws = vs[1..].map { |v| v + RE_IX.source }.join('\s+')
             /
               \A
               #{m}#{RE_IX}
@@ -367,7 +367,7 @@ module AtCoderFriends
           lambda { |vs|
             ws = [
               vs[0] + RE_SZ.source,
-              *vs[1..-1]&.map { |v| v + RE_IX.source }
+              *vs[1..]&.map { |v| v + RE_IX.source }
             ].join('\s+')
             /\A#{ws}\z/
           }
@@ -389,7 +389,7 @@ module AtCoderFriends
             ws1 = vs.map { |v| v + RE_IX.source }.join('\s+')
             ws2 = [
               vs[0] + RE_SZ.source,
-              *vs[1..-1]&.map { |v| v + RE_IX.source }
+              *vs[1..]&.map { |v| v + RE_IX.source }
             ].join('\s+')
             /
               \A
@@ -412,7 +412,7 @@ module AtCoderFriends
           lambda { |vs|
             ws = [
               vs[0] + RE_SZ.source,
-              *vs[1..-1]&.map { |v| v + RE_IX.source }
+              *vs[1..]&.map { |v| v + RE_IX.source }
             ].join('\s+')
             /\A#{ws}\z/
           }