at_coder_friends 0.6.2 → 0.6.7

data/lib/at_coder_friends/parser/input_type.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # parses input data types and updates input definitons
+    module InputType
+      module_function
+
+      NUMBER_PAT = /\A[+-]?[0-9]{1,19}\z/.freeze
+      DECIMAL_PAT = /\A[+-]?[0-9]{1,19}(\.[0-9]+)?\z/.freeze
+      TYPE_TBL = [
+        [:number, NUMBER_PAT],
+        [:decimal, DECIMAL_PAT]
+      ].freeze
+
+      def process(pbm)
+        parse(pbm.formats_src, pbm.samples)
+      end
+
+      def parse(inpdefs, smps)
+        lines = max_smp(smps)&.split("\n")
+        lines && match_smp(inpdefs, lines)
+      end
+
+      def max_smp(smps)
+        smps
+          .select { |smp| smp.ext == :in }
+          .max_by { |smp| smp.txt.size }
+          &.txt
+      end
+
+      def match_smp(inpdefs, lines)
+        vars = {}
+        inpdefs.each do |inpdef|
+          break unless  (k = get_line_cnt(inpdef))
+
+          k, parsed = parse_line_cnt(k, vars)
+          rows = lines.shift(k).map { |line| line.split(/[#{inpdef.delim} ]/) }
+          break if rows.empty?
+
+          inpdef.container == :single &&
+            vars.merge!(inpdef.names.zip(rows[0]).to_h)
+          inpdef.cols = detect_cols_type(rows)
+          break unless parsed
+        end
+        inpdefs
+      end
+
+      def get_line_cnt(inpdef)
+        case inpdef.size.size
+        when 0
+          1
+        when 1
+          inpdef.container == :harray ? 1 : inpdef.size[0]
+        when 2
+          inpdef.size[0]
+        end
+      end
+
+      def parse_line_cnt(k, vars)
+        if k.is_a?(Integer)
+          [k, true]
+        elsif k =~ NUMBER_PAT
+          [k.to_i, true]
+        elsif vars[k] =~ NUMBER_PAT
+          [vars[k].to_i, true]
+        elsif vars[(k2 = k.gsub(/-1\z/, ''))] =~ NUMBER_PAT
+          [vars[k2].to_i - 1, true]
+        else
+          [1, false]
+        end
+      end
+
+      def detect_cols_type(rows)
+        cols = fill_transpose(rows).map(&:compact)
+        cols.map { |col| detect_col_type(col) }
+      end
+
+      def fill_transpose(arr)
+        Array.new(arr.map(&:size).max) { |i| arr.map { |e| e[i] } }
+      end
+
+      def detect_col_type(arr)
+        ret = :string
+        TYPE_TBL.any? do |type, pat|
+          arr.all? { |v| v =~ pat } && ret = type
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/main.rb

@@ -10,6 +10,7 @@ module AtCoderFriends
         Sections.process(pbm)
         SampleData.process(pbm)
         InputFormat.process(pbm)
+        InputType.process(pbm)
         Constraints.process(pbm)
         Modulo.process(pbm)
         Interactive.process(pbm)

data/lib/at_coder_friends/parser/modulo.rb

@@ -21,7 +21,7 @@ module AtCoderFriends
           |\\\(([^()]+)\\\)
           |\$([^$]+)\$
           |\{([^{}]+)\}
-          |([\d,]+)
+          |([\d,^+]+)
           |([一二三四五六七八九十百千万億]+)
         )
       }x.freeze

data/lib/at_coder_friends/parser/sections.rb

@@ -63,7 +63,7 @@ module AtCoderFriends
         {
           key: Problem::SECTION_IN_SMP,
           pattern: /
-            \A(
+            \A(?:
               入力例\s*(?<no>\d+)?
               |入力\s*(?<no>\d+)
               |Sample\s*Input\s*(?<no>\d+)?
@@ -75,14 +75,14 @@ module AtCoderFriends
         {
           key: Problem::SECTION_OUT_SMP,
           pattern: /
-            \A(
+            \A(?:
               出力例\s*(?<no>\d+)?
               |出力\s*(?<no>\d+)
               |入力例\s*(?<no>\d+)?\s*に対する出力例
               |Sample\s*Output\s*(?<no>\d+)?
               |Output\s*Example\s*(?<no>\d+)?
               |Output\s*(?<no>\d+)
-              |Output\s*for\s*(the)?\s*Sample\s*Input\s*(?<no>\d+)?
+              |Output\s*for\s*(?:the)?\s*Sample\s*Input\s*(?<no>\d+)?
             )\z
           /xi
         },

data/lib/at_coder_friends/path_info.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  # holds target path information
+  class PathInfo
+    SMP_DIR = 'data'
+    CASES_DIR = 'cases'
+    TMP_DIR = '.tmp'
+
+    attr_reader :path, :dir
+
+    def initialize(path)
+      @path = path
+      # in setup command, path is directory name (existent/non-existent)
+      # in other commands(test, submit, verify), path is existent file name
+      @dir = File.file?(path) ? File.dirname(path) : path
+    end
+
+    def contest_name
+      File.basename(dir).delete('#').downcase
+    end
+
+    def components
+      # overwrites @dir here for non-existent files (test purpose)
+      @dir, prg = File.split(path)
+      base, ext = prg.split('.')
+      q = base.gsub(/_[^#_]+\z/, '')
+      [path, dir, prg, base, ext, q]
+    end
+
+    def src_dir
+      dir
+    end
+
+    def smp_dir
+      File.join(dir, SMP_DIR)
+    end
+
+    def cases_dir
+      File.join(dir, CASES_DIR)
+    end
+
+    def cases_out_dir
+      File.join(dir, TMP_DIR, CASES_DIR)
+    end
+
+    def tmp_dir
+      File.join(dir, TMP_DIR)
+    end
+  end
+end

data/lib/at_coder_friends/path_util.rb

@@ -3,37 +3,6 @@
 module AtCoderFriends
   # Common methods and behaviors for dealing with paths.
   module PathUtil
-    module_function
-
-    SMP_DIR = 'data'
-    CASES_DIR = 'cases'
-    TMP_DIR = '.tmp'
-
-    def contest_name(path)
-      dir = File.file?(path) ? File.dirname(path) : path
-      File.basename(dir).delete('#').downcase
-    end
-
-    def split_prg_path(path)
-      dir, prg = File.split(path)
-      base, ext = prg.split('.')
-      q = base.split('_')[0]
-      [path, dir, prg, base, ext, q]
-    end
-
-    def smp_dir(dir)
-      File.join(dir, SMP_DIR)
-    end
-
-    def cases_dir(dir)
-      File.join(dir, CASES_DIR)
-    end
-
-    def tmp_dir(path)
-      dir = File.dirname(path)
-      File.join(dir, '.tmp')
-    end
-
     def makedirs_unless(dir)
       FileUtils.makedirs(dir) unless Dir.exist?(dir)
     end

data/lib/at_coder_friends/problem.rb

@@ -18,13 +18,84 @@ module AtCoderFriends
 
     SampleData = Struct.new(:no, :ext, :txt)
 
-    InputFormat = Struct.new(:container, :item, :names, :size) do
-      def initialize(container, item, names, size = [])
-        super(container, item, names, size)
+    # holds information about input format
+    class InputFormat
+      ITEM_RANK = { number: 1, decimal: 2, string: 3 }.freeze
+
+      attr_reader :container, :names, :size, :delim
+      attr_accessor :cols
+
+      def initialize(
+        container: nil,
+        item: nil,
+        names: [],
+        size: [],
+        delim: '',
+        cols: []
+      )
+        @container = container
+        @item = item
+        @names = names
+        @size = size
+        @delim = delim
+        @cols = cols
       end
 
       def to_s
-        "#{container} #{item} #{names} #{size}"
+        if container == :unknown
+          "#{container} #{item}"
+        else
+          "#{container} #{item}(#{cols}) #{names} #{size} #{delim}"
+        end
+      end
+
+      def item
+        @item || cols.max_by { |k| ITEM_RANK[k] } || :number
+      end
+
+      def vars
+        tmp = @item && [@item] || cols
+        names.zip(tmp).map { |(name, col)| [name, col || :number] }
+      end
+
+      def components
+        @components ||=
+          case container
+          when :varray_matrix
+            varray_matrix_components
+          when :matrix_varray
+            matrix_varray_components
+          end
+      end
+
+      def varray_matrix_components
+        [
+          self.class.new(
+            container: :varray,
+            names: names[0..-2], size: size[0..0],
+            delim: delim, cols: cols[0..-2]
+          ),
+          self.class.new(
+            container: :matrix, item: @item,
+            names: names[-1..-1], size: size,
+            delim: delim, cols: cols[-1..-1] || []
+          )
+        ]
+      end
+
+      def matrix_varray_components
+        [
+          self.class.new(
+            container: :matrix, item: @item,
+            names: names[0..0], size: size,
+            delim: delim, cols: cols[0..0]
+          ),
+          self.class.new(
+            container: :varray,
+            names: names[1..-1], size: size[0..0],
+            delim: delim, cols: cols[1..-1] || []
+          )
+        ]
       end
     end
 
@@ -35,14 +106,14 @@ module AtCoderFriends
     SourceCode = Struct.new(:ext, :txt)
 
     attr_reader :q, :samples, :sources, :options
-    attr_accessor :page, :sections, :formats, :constants
+    attr_accessor :page, :sections, :formats_src, :constants
 
     def initialize(q, page = Mechanize::Page.new)
       @q = q
       @page = page
       @sections = {}
       @samples = []
-      @formats = []
+      @formats_src = []
       @constants = []
       @options = Options.new
       @sources = []
@@ -57,6 +128,10 @@ module AtCoderFriends
       @body_content ||= page.search('body')[0]&.content
     end
 
+    def formats
+      @formats ||= formats_src.reject { |f| f.container == :unknown }
+    end
+
     def add_smp(no, ext, txt)
       @samples << SampleData.new(no, ext, txt)
     end

data/lib/at_coder_friends/scraping/agent.rb

@@ -7,7 +7,6 @@ module AtCoderFriends
   module Scraping
     # common functions for scraping
     class Agent
-      include AtCoderFriends::PathUtil
       include Session
       include Authentication
       include Tasks
@@ -29,7 +28,7 @@ module AtCoderFriends
       end
 
       def contest
-        @contest ||= contest_name(ctx.path)
+        @contest ||= ctx.path_info.contest_name
       end
 
       def common_url(path)
@@ -41,6 +40,10 @@ module AtCoderFriends
       end
 
       def lang_id(ext)
+        [lang_id_conf(ext)].flatten
+      end
+
+      def lang_id_conf(ext)
         ctx.config.dig('ext_settings', ext, 'submit_lang') || (
           msg = <<~MSG
             submit_lang for .#{ext} is not specified.
@@ -51,6 +54,12 @@ module AtCoderFriends
         )
       end
 
+      def find_lang(page, langs)
+        langs.find do |lng|
+          page.search("div#select-lang select option[value=#{lng}]")[0]
+        end || langs[0]
+      end
+
       def lang_list_txt
         lang_list
           &.map { |opt| "#{opt[:v]} - #{opt[:t]}" }

data/lib/at_coder_friends/scraping/custom_test.rb

@@ -6,20 +6,19 @@ module AtCoderFriends
   module Scraping
     # run tests on custom_test page
     module CustomTest
-      include AtCoderFriends::PathUtil
-
       def code_test(infile)
-        path, _dir, _prg, _base, ext, _q = split_prg_path(ctx.path)
-        lang = lang_id(ext)
+        path, _dir, _prg, _base, ext, _q = ctx.path_info.components
+        langs = lang_id(ext)
         src = File.read(path, encoding: Encoding::UTF_8)
         data = File.read(infile)
 
-        post_custom_test(lang, src, data)
+        post_custom_test(langs, src, data)
         check_custom_test
       end
 
-      def post_custom_test(lang, src, data)
+      def post_custom_test(langs, src, data)
         page = fetch_with_auth(contest_url('custom_test'))
+        lang = find_lang(page, langs)
         script = page.search('script').text
         csrf_token = script.scan(/var csrfToken = "(.*)"/)[0][0]
 

data/lib/at_coder_friends/scraping/submission.rb

@@ -4,22 +4,21 @@ module AtCoderFriends
   module Scraping
     # submit sources on submit page
     module Submission
-      include AtCoderFriends::PathUtil
-
       def submit
-        path, _dir, prg, _base, ext, q = split_prg_path(ctx.path)
+        path, _dir, prg, _base, ext, q = ctx.path_info.components
         puts "***** submit #{prg} *****"
-        lang = lang_id(ext)
+        langs = lang_id(ext)
         src = File.read(path, encoding: Encoding::UTF_8)
 
-        post_submit(q, lang, src)
+        post_submit(q, langs, src)
       end
 
-      def post_submit(q, lang, src)
+      def post_submit(q, langs, src)
         page = fetch_with_auth(contest_url('submit'))
+        lang = find_lang(page, langs)
         form = page.forms[1]
         form.field_with(name: 'data.TaskScreenName') do |sel|
-          option = sel.options.find { |op| op.text.start_with?(q) }
+          option = sel.options.find { |op| op.text =~ /\A#{q}\W/ }
           option&.select || (raise AppError, "unknown problem:#{q}.")
         end
         form.add_field!('data.LanguageId', lang)

data/lib/at_coder_friends/scraping/tasks.rb

@@ -7,9 +7,14 @@ module AtCoderFriends
       def fetch_all
         puts "***** fetch_all #{contest} *****"
         fetch_assignments.map do |q, url|
-          pbm = fetch_problem(q, url)
-          yield pbm if block_given?
-          pbm
+          begin
+            pbm = fetch_problem(q, url)
+            yield pbm if block_given?
+            pbm
+          rescue StandardError => e
+            puts e.to_s
+            puts e.backtrace
+          end
         end
       end