at_coder_friends 0.6.8 → 0.7.0

data/lib/at_coder_friends/generator/base.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require 'erb'
 
 module AtCoderFriends
   module Generator
-    Attributes = Struct.new(:file_ext, :default_template)
+    Attributes = Struct.new(:file_ext, :template, :fragments)
 
     # common behavior of generators
     class Base
+      ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
+      TMPL_DIR = File.join(ACF_HOME, 'templates')
+
       attr_reader :cfg, :pbm
 
       def initialize(cfg = nil)
@@ -15,21 +19,36 @@ module AtCoderFriends
       end
 
       def process(pbm)
-        pbm.add_src(attrs.file_ext, generate(pbm))
+        pbm.add_src(config_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)
+        template = File.read(config_template)
+        src = ERB.new(template, trim_mode: '-').result(binding)
         src = render(src) if respond_to?(:render)
         src
       end
 
-      def select_template
-        cfg['default_template'] || attrs.default_template
+      def fragments
+        @fragments ||= YAML.load_file(config_fragments)
+      end
+
+      def config_file_ext
+        cfg['file_ext']&.to_sym || attrs.file_ext
       end
 
+      def config_template
+        template = cfg['template'] || cfg['default_template'] || attrs.template
+        template.sub(/\A@/, TMPL_DIR)
+      end
+
+      def config_fragments
+        fragments = cfg['fragments'] || attrs.fragments
+        fragments.sub(/\A@/, TMPL_DIR)
+      end
+
+      # deprecated, use ERB syntax
       def embed_lines(src, pat, lines)
         re = Regexp.escape(pat)
         src.gsub(
@@ -38,5 +57,35 @@ module AtCoderFriends
         )
       end
     end
+
+    module ConstFragmentMixin
+      def gen_consts
+        pbm.constants.map { |c| gen_const(c) }
+      end
+
+      def gen_const(c)
+        ConstFragment.new(c, fragments['constant']).generate
+      end
+    end
+
+    module DeclFragmentMixin
+      def gen_decls
+        pbm.formats.map { |inpdef| gen_decl(inpdef).split("\n") }.flatten
+      end
+
+      def gen_decl(inpdef)
+        InputFormatFragment.new(inpdef, fragments['declaration']).generate
+      end
+    end
+
+    module InputFragmentMixin
+      def gen_inputs
+        pbm.formats.map { |inpdef| gen_input(inpdef).split("\n") }.flatten
+      end
+
+      def gen_input(inpdef)
+        InputFormatFragment.new(inpdef, fragments['input']).generate
+      end
+    end
   end
 end

data/lib/at_coder_friends/generator/c_builtin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Generator
+    # generates C source from problem description
+    class CBuiltin < Base
+      include ConstFragmentMixin
+      include DeclFragmentMixin
+      include InputFragmentMixin
+
+      ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
+      TMPL_DIR = File.join(ACF_HOME, 'templates')
+      TEMPLATE = File.join(TMPL_DIR, 'c_builtin.c.erb')
+      FRAGMENTS = File.join(TMPL_DIR, 'c_builtin_fragments.yml')
+      ATTRS = Attributes.new(:c, TEMPLATE, FRAGMENTS)
+
+      def attrs
+        ATTRS
+      end
+    end
+  end
+end

data/lib/at_coder_friends/generator/cxx_builtin.rb

@@ -2,256 +2,24 @@
 
 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)
-        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
+        embed_lines(src, '/*** INPUTS ***/', gen_inputs)
       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

@@ -12,34 +12,40 @@ module AtCoderFriends
       end
 
       def process(pbm)
-        generators = ctx.config.dig('generators') || []
+        generators = ctx.config['generators'] || []
         generators.each do |gen_name|
-          begin
-            gen_obj = load_obj(gen_name)
-            gen_obj.process(pbm)
-          rescue StandardError => e
-            puts "an error occurred in generator:#{gen_name}."
-            puts e.to_s
-            puts e.backtrace
-          end
+          gen_obj = load_obj(gen_name)
+          gen_obj.process(pbm)
+        rescue StandardError => e
+          puts "an error occurred in generator:#{gen_name}."
+          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)