at_coder_friends 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54e37c0175b9736f4e99b6243af3b8970f34bef3
-  data.tar.gz: 588075eda25ca77b7f5fcef1f7b6158e97274af5
+  metadata.gz: b8025722558e20114e202913981972cc89885a7f
+  data.tar.gz: 52975c30a2ac79ca4b459b2466de8c8b244f2296
 SHA512:
-  metadata.gz: e2f1ef0a2dc869c89ff693c884fa23a61675d472cc3d3ef55f0d4f3d7faf880114584e0b9fde3207493502963a8d8b2cab4ef64aaca830dd1b580514c4bf1e6c
-  data.tar.gz: 2e707b0b63b1dedbd9df0f93bd7cd9cfaf4614cf7c731c63d2f4cd5382ad1944baed2bbac6bf829d1362c61b8761a37e6299c35e42e80b0d903edc3ce2c582c6
+  metadata.gz: 14a7f27ec8de72d1ecafe5e27810ac781aedc23c5604e33005856398250e07617ed803dc6641ad17e45b7de8f8ae09c20fffd9997f64a34e1f4dc3f10beb63d6
+  data.tar.gz: 0fb4f2e1afb371a7ad49ad69e9ae22fe169856a7268daf4fc78054192bba532181b82e9290d5965d5cf608ea92d85b23bb4c71f976c814adac32e704e4311eeb

data/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Change log
+
+## master (unreleased)
+
+## 0.6.2 (2019-11-18)
+### Added
+- add ```check-and-go``` command.
+
+### Changed
+- Enhancement in input format parser.
+
+## 0.6.1 (2019-10-28)
+### Added
+- Extract MOD values from problem description.
+
+### Changed
+- Enhancement in MAX value parser.
+
+## 0.6.0 (2019-10-21)
+### Added
+- Output problem url to generated sources.
+- Interactive problem support.
+- Binary problem support.
+- Add settings about source generation.
+
+### Changed
+- Treat all ```A_*.in``` format files as sample input data
+
+## 0.5.2 (2019-10-14)
+### Fixed
+- Fix input format parser.
+
+## 0.5.1 (2019-10-14)
+### Added
+- Colored test results.
+
+### Changed
+- Enhancement in sample data parser.
+- Enhancement in input format parser.
+
+## 0.5.0 (2019-10-04)
+### Added
+- User/password setting in ```.at_coder_friends.yml``` is no longer required.
+- Saving and restoring session feature.
+
+## 0.4.0 (2019-09-16)
+### Added
+- Test and submission are now available in 36 languages.
+
+## 0.3.3 (2019-09-01)
+### Added
+- Add ```open-contest-page``` command.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    at_coder_friends (0.6.1)
+    at_coder_friends (0.6.2)
       colorize (~> 0.8.1)
       launchy (~> 2.4.3)
       mechanize (~> 2.0)
@@ -36,7 +36,7 @@ GEM
       webrobots (>= 0.0.9, < 0.2)
     mime-types (3.3)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2019.0904)
+    mime-types-data (3.2019.1009)
     mini_portile2 (2.4.0)
     net-http-digest_auth (1.4.1)
     net-http-persistent (3.1.0)
@@ -45,7 +45,7 @@ GEM
       mini_portile2 (~> 2.4.0)
     ntlm-http (0.1.1)
     public_suffix (4.0.1)
-    rake (13.0.0)
+    rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)

data/README.md

@@ -40,7 +40,7 @@ Or install it yourself as:
 ### Setup
 
 ```
-at_coder_friends setup     /path/to/contest
+at_coder_friends setup         /path/to/contest
 ```
 
 Creates contest folder, and generates example data and source skeletons into the folder.
@@ -56,19 +56,25 @@ Opens the contet page which the contest folder linked to.
 ### Run first test case
 
 ```
-at_coder_friends test-one  /path/to/contest/source_file
+at_coder_friends test-one      /path/to/contest/source_file
 ```
 
 ### Run all test cases
 
 ```
-at_coder_friends test-all  /path/to/contest/source_file
+at_coder_friends test-all      /path/to/contest/source_file
 ```
 
 ### Submit code
 
 ```
-at_coder_friends submit    /path/to/contest/source_file
+at_coder_friends submit        /path/to/contest/source_file
+```
+
+### Submit code automatically if all tests passed
+
+```
+at_coder_friends check-and-go  /path/to/contest/source_file
 ```
 
 ### Naming convention
@@ -80,14 +86,16 @@ at_coder_friends submit    /path/to/contest/source_file
 - Suffixes (start with underscore) may be added to the file name (e.g. ```A_v2.rb```),
   so that you can try multiple codes for one problem.
 
-## Configuration
-
-See [CONFIGURATION.md](docs/CONFIGURATION.md) for details.
-
 ## Notes
 
 - Compilation is not supported.
-- Source generator supports only Ruby and C++ in default.
+- Source generator supports Ruby and C++ in default, and can be added by plugin.
+- Test runner and code submission are supported in 36 languages.
+
+
+## Configuration
+
+See [CONFIGURATION.md](docs/CONFIGURATION.md) for details.
 
 ## For Sublime Text user
 
@@ -150,6 +158,17 @@ It is convenient to use AtCoderFriends from Sublime Text plugin.
       "problemMatcher": [],
       "group": "none",
     },
+    {
+      "label": "AtCoderFriends:Check & Go",
+      "type": "shell",
+      "command": "at_coder_friends",
+      "args": [
+        "check-and-go",
+        "${file}"
+      ],
+      "problemMatcher": [],
+      "group": "none",
+    },
     ...
   ],
   "inputs": [

data/at_coder_friends.gemspec

@@ -21,8 +21,10 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/nejiko96/at_coder_friends'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -30,6 +32,12 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.3.0'
 
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => 'https://github.com/nejiko96/at_coder_friends/blob/master/CHANGELOG.md'
+  }
+
   spec.add_dependency 'colorize', '~> 0.8.1'
   spec.add_dependency 'launchy', '~> 2.4.3'
   spec.add_dependency 'mechanize', '~> 2.0'

data/docs/CONFIGURATION.md

@@ -133,12 +133,12 @@ ext_settings:
 - generators  
   List of source generator class names  
   In default, ```RubyBuiltin``` and ```CxxBuiltin``` are available.  
-  For those other than above, corresponding plugin will be used  
-  if it has been installed (?).  
-  ソーススケルトンを生成するジェネレータのクラス名（リスト形式）  
+  For other generators, corresponding plugin will be used  
+  if it has been installed.  
+  ソースジェネレータのクラス名（リスト形式）  
   既定の状態では「RubyBuiltin」と「CxxBuiltin」が利用でき、  
-  上記以外については、対応するプラグインがインストールされていれば  
-  それが使われます（？）  
+  その他のジェネレータは、対応するプラグインがインストールされていれば  
+  利用できます  
 
   For example, if ```RubyAlt``` is specified as generator name,  
   following plugin will be used:
@@ -148,6 +148,8 @@ ext_settings:
     |Gem Name         |```at_coder_friends-generator-ruby_alt```          |
     |Require Statement|```require 'at_coder_friends/generator/ruby_alt'```|
     |Main Class Name  |```AtCoderFriends::Generator::RubyAlt```           |
+  
+  [search generator in GitHub](https://github.com/search?q=at_coder_friends-generator)
 
 - generator_settings
   - _(generator name)_  

data/lib/at_coder_friends/cli.rb

@@ -14,6 +14,7 @@ module AtCoderFriends
           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
+          at_coder_friends check-and-go path/contest/src   # submit source if all tests passed
           at_coder_friends open-contest path/contest/src   # open contest page
         Options:
       TEXT
@@ -75,6 +76,8 @@ module AtCoderFriends
         test_all
       when 'submit'
         submit
+      when 'check-and-go'
+        check_and_go
       when 'judge-one'
         judge_one(*args)
       when 'judge-all'
@@ -116,6 +119,18 @@ module AtCoderFriends
       vf.unverify
     end
 
+    def check_and_go
+      vf = ctx.verifier
+      if ctx.sample_test_runner.test_all
+        # submit automatically
+        ctx.scraping_agent.submit
+        vf.unverify
+      else
+        # enable manual submit
+        vf.verify
+      end
+    end
+
     def judge_one(id = '')
       ctx.judge_test_runner.judge_one(id)
     end

data/lib/at_coder_friends/generator/cxx_builtin.rb

@@ -43,7 +43,7 @@ module AtCoderFriends
       TEXT
     end
 
-    # generates C++ source code from problem description
+    # generates C++ source from problem description
     class CxxBuiltin
       include CxxBuiltinConstants
 
@@ -174,7 +174,7 @@ module AtCoderFriends
       end
 
       def gen_arr_size(szs)
-        szs.map { |sz| sz =~ /\D/ ? "#{sz.upcase}_MAX" : sz }
+        szs.map { |sz| sz.gsub(/([a-z][a-z0-9_]*)/i, '\1_MAX').upcase }
       end
 
       def gen_inputs(inpdefs = pbm.formats)

data/lib/at_coder_friends/generator/ruby_builtin.rb

@@ -2,7 +2,7 @@
 
 module AtCoderFriends
   module Generator
-    # generates C++ source code from problem description
+    # generates Ruby source from problem description
     class RubyBuiltin
       ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
       TMPL_DIR = File.join(ACF_HOME, 'templates')

data/lib/at_coder_friends/parser/constraints.rb

@@ -49,13 +49,13 @@ module AtCoderFriends
         # 2) {i, j}->{i,j} {N-1}->{N} shortest match
         s
           .tr('０-９Ａ-Ｚａ-ｚ', '0-9A-Za-z')
-          .gsub(/[[:space:]]/) { |c| c.gsub(/[^\t\r\n]/, ' ') } # 1)
+          .gsub(/[[:space:]]/) { |c| c.gsub(/[^\t\n]/, ' ') } # 1)
           .gsub(%r{</?var>}i, "\t")
           .gsub(%r{<sup>([^<>]+)</sup>}i, '^\1')
           .gsub(%r{<sub>([^<>]+)</sub>}i, '_{\1}')
-          .gsub('&amp;', '&')
           .gsub(/<("[^"]*"|'[^']*'|[^'"<>])*>/, '')
-          .gsub(/(＜|≦|≤|&lt;|&leq?;|\\lt|\\leq?q?)(\{\})?/i, '<')
+          .gsub('&amp;', '&')
+          .gsub(/(＜|≦|≤|&lt;|&leq?;|\\lt|\\leq?q?)/i, '<')
           .gsub('\\ ', ' ')
           .gsub('\\,', ',')
           .gsub('\\|', '|')
@@ -65,6 +65,9 @@ module AtCoderFriends
           .gsub('\\rvert', '|')
           .gsub('\\mathit', '')
           .gsub('\\times', '*')
+          .gsub(/\\begin(\{[^{}]*\})*/, '')
+          .gsub(/\\end(\{[^{}]*\})*/, '')
+          .gsub(/\{\}/, ' ')
           .gsub('|', '')
           .gsub(/\{.*?\}/) { |w| w.delete(' ()').gsub(/{(.+)-1}\z/, '\1') } # 2)
       end

data/lib/at_coder_friends/parser/input_format.rb

@@ -2,63 +2,126 @@
 
 module AtCoderFriends
   module Parser
+    InputFormatMatcher = Struct.new(:container, :item, :pat, :gen_names, :gen_pat2) do
+      attr_reader :names, :size
+
+      def match(str)
+        return false unless (m1 = pat.match(str))
+
+        @names = gen_names.call(m1)
+        @pat2 = gen_pat2&.call(names)
+        @size = m1.names.include?('sz') && m1['sz'] || ''
+        true
+      end
+
+      def match2(str)
+        return false unless @pat2
+        return true if /\A\.+\z/ =~ str
+        return false unless (m2 = @pat2.match(str))
+
+        m2.names.include?('sz') && @size = m2['sz']
+        true
+      end
+    end
+
     module InputFormatConstants
       SECTIONS = [
         Problem::SECTION_IN_FMT,
         Problem::SECTION_IO_FMT
       ].freeze
-      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: ->(_) { [] }
-        }
+      ITEM_PAT = /\{*[A-Za-z]+(?:_[A-Za-z]+)*\}*/.freeze
+      SZ = '(_(?<sz>\S+)|{(?<sz>\S+)})'
+      SINGLE_PAT = /([A-Za-z{][A-Za-z_0-9{}]*)/.freeze
+      MATCHERS = [
+        InputFormatMatcher.new(
+          :matrix, :number,
+          /
+            \A
+            (?<v>#{ITEM_PAT})[_{]\{*[01][,_]?[01]\}*
+            (\s+\k<v>[_{]\S+)*
+            (\s+\.+)?
+            (\s+\k<v>#{SZ})+
+            \z
+          /x,
+          ->(m) { [m[:v]] },
+          lambda { |((v))|
+            /
+              \A
+              #{v}[_{]\S+
+              (\s+#{v}#{SZ})*
+              (\s+\.+)?
+              (\s+#{v}#{SZ})*
+              \z
+            /x
+          }
+        ),
+        InputFormatMatcher.new(
+          :matrix, :char,
+          /
+            \A
+            (?<v>#{ITEM_PAT})[_{]\{*[01][,_]?[01]\}*
+            (\k<v>[_{]\S+)*
+            (\s*\.+\s*)?
+            (\k<v>#{SZ})+
+            \z
+          /x,
+          ->(m) { [m[:v]] },
+          lambda { |((v))|
+            /
+              \A
+              (#{v}[_{]\S+)+
+              (\s*\.+\s*)?
+              (#{v}#{SZ})+
+              \z
+            /x
+          }
+        ),
+        InputFormatMatcher.new(
+          :harray, :number,
+          /
+            \A
+            (?<v>#{ITEM_PAT})[_{]\{*[0-9]\}*
+            (\s+\k<v>[_{]\S+)*
+            (\s+\.+)?
+            (\s+\k<v>#{SZ})+
+            \z
+          /x,
+          ->(m) { [m[:v]] },
+          nil
+        ),
+        InputFormatMatcher.new(
+          :harray, :char,
+          /
+            \A
+            (?<v>#{ITEM_PAT})[_{]\{*[0-9]\}*
+            (\k<v>[_{]\S+)*
+            (\s*\.+\s*)?
+            (\k<v>#{SZ})+
+            \z
+          /x,
+          ->(m) { [m[:v]] },
+          nil
+        ),
+        InputFormatMatcher.new(
+          :varray, :number,
+          /
+            \A
+            #{ITEM_PAT}[_{]\{*(?<sz>[0-9]+)\}*
+            (\s+#{ITEM_PAT}[_{]\{*\k<sz>\}*)*
+            \z
+          /x,
+          ->(m) { m[0].split.map { |w| w.scan(ITEM_PAT)[0] } },
+          lambda { |vs|
+            pat2 = vs.map { |v| v + SZ }.join('\s+')
+            /\A#{pat2}\z/
+          }
+        ),
+        InputFormatMatcher.new(
+          :single, :number,
+          /\A(.*\s)?#{SINGLE_PAT}(\s.*)?\z/,
+          ->(m) { m[0].split.select { |w| w =~ /\A#{SINGLE_PAT}\z/ } },
+          nil
+        )
       ].freeze
     end
 
@@ -68,80 +131,135 @@ module AtCoderFriends
 
       module_function
 
-      # 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
-
       def process(pbm)
-        str =
-          SECTIONS
-          .map { |key| pbm.sections[key]&.code_block }
-          .find(&:itself) || ''
+        return unless (str = find_fmt(pbm))
+
         inpdefs = parse(str, pbm.samples)
         pbm.formats = inpdefs
       end
 
+      def find_fmt(pbm)
+        str = nil
+        SECTIONS.any? do |key|
+          str = pbm.sections[key]&.code_block_html
+          str && !str.empty?
+        end
+        str
+      end
+
       def parse(str, smps)
-        lines = normalize(str)
+        lines = normalize_fmt(str)
         inpdefs = parse_fmt(lines)
+        normalize_defs!(inpdefs)
         smpx = max_smp(smps)
         smpx && match_smp!(inpdefs, smpx)
         inpdefs
       end
 
-      def normalize(fmt)
+      def normalize_fmt(fmt)
+        # 1) &npsp; , fill-width space -> half width space
+        # 2) {i, j}->{i,j} for nested {}
         fmt
-          .gsub(/[+*-]\d+/, '') # 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(/[clv]?dots/, '..')
-          .gsub(/^\s*\.[.\s]*$/, '..')
+          .tr('０-９Ａ-Ｚａ-ｚ', '0-9A-Za-z')
+          .gsub(/[[:space:]]/) { |c| c.gsub(/[^\n]/, ' ') } # 1)
+          .gsub(%r{<var>([^<>]+)</var>}i, '\1') # <sub><var>N</var></sub>
+          .gsub(%r{<sup>([^<>]+)</sup>}i, '^\1')
+          .gsub(%r{<sub>([^<>]+)</sub>}i, '_{\1}')
+          .gsub(%r{<sub>([^<>]+)</sub>}i, '_{\1}') # for nested<sub>
+          .gsub(/<("[^"]*"|'[^']*'|[^'"<>])*>/, '')
+          .gsub('&amp;', '&')
+          .gsub('&gt;', '>')
+          .gsub('&lt;', '<')
+          .gsub('\\ ', ' ')
+          .gsub('\\(', '')
+          .gsub('\\)', '')
+          .gsub('\\lvert', '|')
+          .gsub('\\rvert', '|')
+          .gsub('\\mathit', '')
+          .gsub('\\times', '*')
+          .gsub(/\\begin(\{[^{}]*\})*/, '')
+          .gsub(/\\end(\{[^{}]*\})*/, '')
+          .gsub(/\\[cdlv]?dots/, '..')
+          .gsub(/\{\}/, ' ')
+          .gsub('−', '-') # fill width hyphen
+          .gsub(/[・：‥⋮︙…]+/, '..')
+          .gsub(/[\\$']/, '') # s' -> s
+          .gsub(/[&~|]/, ' ') # |S| -> S
+          .gsub(%r{[-/:](#{SINGLE_PAT})}, ' \1') # a-b, a/b, a:b -> a b
+          .gsub(/^\s*[.:][\s.:]*$/, '..')
+          .tr('()', '{}')
+          .gsub(/(?<bl>\{(?:[^{}]|\g<bl>)*\})/) { |w| w.delete(' ') } # 2)
           .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 << Problem::InputFormat.new(container, item, names, size)
+        matcher = nil
+        (lines + ['']).each_with_object([]) do |line, ret|
+          if matcher
+            next if matcher.match2(line)
+
+            ret.last.size = matcher.size
           end
-        end.to_a
+          if (matcher = MATCHERS.find { |m| m.match(line) })
+            ret << Problem::InputFormat.new(
+              matcher.container, matcher.item, matcher.names, ''
+            )
+          elsif !line.empty?
+            puts "unknown format: #{line}"
+            # ret << Problem::InputFormat.new(:unknown, nil, line)
+          end
+        end
+      end
+
+      def normalize_defs!(inpdefs)
+        inpdefs.each do |inpdef|
+          inpdef.names = normalize_names(inpdef.names)
+          inpdef.size = normalize_size(inpdef.container, inpdef.size)
+        end
+      end
+
+      def normalize_names(names)
+        return names unless names.is_a?(Array)
+
+        names.map { |nm| nm.delete('{}').gsub(/(\A_+|_+\z)/, '') }
+      end
+
+      def normalize_size(container, size)
+        sz =
+          case container
+          when :matrix
+            matrix_size(size)
+          when :harray, :varray
+            [size]
+          else
+            []
+          end
+        sz.map do |w|
+          w
+            .delete('{},')
+            .gsub(/(\A_+|(_|-1)+\z)/, '') # extra underscores, N-1 -> N
+        end
+      end
+
+      def matrix_size(str)
+        sz = str.scan(/([^{}]+|\{[^{}]+\}})/).flatten
+        return sz if sz.size == 2
+
+        sz = str.split(',')
+        return sz if sz.size == 2
+
+        sz = str.split('_')
+        return sz if sz.size == 2
+
+        str = str.delete('{},')
+        len = str.size
+        if len.positive? && len.even?
+          return str.chars.each_slice(len / 2).map(&:join)
+        end
+
+        [str[0] || '_', str[1..-1] || '_']
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def max_smp(smps)
         smps

data/lib/at_coder_friends/parser/sample_data.rb

@@ -16,7 +16,9 @@ module AtCoderFriends
             elsif key =~ Problem::SECTION_OUT_SMP_PAT
               :exp
             end
-          ext && pbm.add_smp($LAST_MATCH_INFO[:no], ext, section.code_block)
+          ext && pbm.add_smp(
+            $LAST_MATCH_INFO[:no], ext, section.code_block_content
+          )
         end
       end
     end

data/lib/at_coder_friends/parser/section_wrapper.rb

@@ -24,13 +24,13 @@ module AtCoderFriends
 
       def content
         @content ||= begin
-          siblings.reduce('') { |m, node| m + node.content.gsub("\r\n", "\n") }
+          siblings.reduce('') { |m, node| m + node.content }.gsub("\r\n", "\n")
         end
       end
 
       def html
         @html ||= begin
-          siblings.reduce('') { |m, node| m + node.to_html.gsub("\r\n", "\n") }
+          siblings.reduce('') { |m, node| m + node.to_html }.gsub("\r\n", "\n")
         end
       end
 
@@ -44,11 +44,17 @@ module AtCoderFriends
         elem
       end
 
-      def code_block
-        @code_block ||= begin
-          elem = find_element(%w[pre blockquote])
-          (elem&.content || '').lstrip.gsub("\r\n", "\n")
-        end
+      def code_block_content
+        @code_block_content ||= code_block(:content)
+      end
+
+      def code_block_html
+        @code_block_html ||= code_block(:to_html)
+      end
+
+      def code_block(mtd)
+        elem = find_element(%w[pre blockquote])
+        elem && elem.send(mtd).lstrip.gsub("\r\n", "\n") || ''
       end
     end
   end

data/lib/at_coder_friends/problem.rb

@@ -22,6 +22,10 @@ module AtCoderFriends
       def initialize(container, item, names, size = [])
         super(container, item, names, size)
       end
+
+      def to_s
+        "#{container} #{item} #{names} #{size}"
+      end
     end
 
     Constant = Struct.new(:name, :type, :value)

data/lib/at_coder_friends/scraping/authentication.rb

@@ -22,7 +22,6 @@ module AtCoderFriends
         begin
           return agent.get(url)
         rescue Mechanize::ResponseCodeError => e
-          raise e unless e.response_code == '404'
           raise e if username_link(e.page)
         end
 
@@ -40,13 +39,13 @@ module AtCoderFriends
       def read_auth
         user = ctx.config['user'].to_s
         if user.empty?
-          print('Enter username:')
+          print('enter username:')
           user = STDIN.gets.chomp
         end
 
         pass = ctx.config['password'].to_s
         if pass.empty?
-          print("Enter password for #{user}:")
+          print("enter password for #{user}:")
           pass = STDIN.noecho(&:gets).chomp
           puts
         end
@@ -59,7 +58,7 @@ module AtCoderFriends
         @username = (link ? link.text.strip : '-')
         return if @username == username_bak || @username == '-'
 
-        puts "Logged in as #{@username}"
+        puts "logged in as #{@username}"
       end
 
       def username_link(page)

data/lib/at_coder_friends/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtCoderFriends
-  VERSION = '0.6.1'
+  VERSION = '0.6.2'
 end

data/tasks/regression/check_fmt.rake

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'regression'
+
+module AtCoderFriends
+  # tasks for regression
+  module Regression
+    module_function
+
+    def check_fmt
+      File.open(log_path('check_fmt.txt'), 'w') do |f|
+        local_pbm_list.sort.each do |contest, q, url|
+          pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+          Parser::Sections.process(pbm)
+          fmt = Parser::InputFormat.find_fmt(pbm)
+          next unless fmt && !fmt.empty?
+
+          n_fmt = Parser::InputFormat.normalize_fmt(fmt).join("\n")
+          Parser::InputFormat.process(pbm)
+          res = pbm.formats.map(&:to_s).join("\n")
+          f.puts [
+            contest, q,
+            tsv_escape(fmt),
+            tsv_escape(n_fmt),
+            tsv_escape(res)
+          ].join("\t")
+        end
+      end
+    end
+
+    def tsv_escape(str)
+      '"' + str.gsub('"', '""').gsub("\t", ' ') + '"'
+    end
+  end
+end
+
+namespace :regression do
+  desc 'checks input format patterns'
+  task :check_fmt do
+    AtCoderFriends::Regression.check_fmt
+  end
+end

data/tasks/regression/check_parse.rake

@@ -8,33 +8,43 @@ module AtCoderFriends
   module Regression
     module_function
 
-    def check_parse(arg)
-      arg ||= 'fmt,smp,int'
+    def check_parse
       list = local_pbm_list.map do |contest, q, url|
         pbm = scraping_agent(nil, contest).fetch_problem(q, url)
         Parser::Main.process(pbm)
-        tbl = {
-          'fmt' => !fmt?(pbm),
-          'smp' => pbm.samples.all? { |smp| smp.txt.empty? },
-          'int' => pbm.options.interactive,
-          'bin' => pbm.options.binary_values
-        }
-        [contest, q, tbl.values_at(*arg.split(','))]
+        flags = [
+          !fmt?(pbm),
+          pbm.samples.all? { |smp| smp.txt.empty? },
+          pbm.options.interactive
+        ]
+        [contest, q, flags]
       end
-      report(list)
+      report(list, 'check_parse.txt')
+    end
+
+    def check_bin
+      list = local_pbm_list.map do |contest, q, url|
+        pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+        Parser::Main.process(pbm)
+        flags = [pbm.options.binary_values]
+        [contest, q, flags]
+      end
+      report(list, 'check_bin.txt')
     end
 
     def fmt?(pbm)
-      [Problem::SECTION_IN_FMT, Problem::SECTION_IO_FMT]
-        .any? { |key| pbm.sections[key]&.code_block&.size&.positive? }
+      fmt = Parser::InputFormat.find_fmt(pbm)
+      fmt && !fmt.empty?
     end
 
-    def report(list)
-      list
-        .select { |_, _, flags| flags.any? }
-        .map { |c, q, flags| [c, q, flags.map { |f| f_to_s(f) }] }
-        .sort
-        .each { |args| puts args.flatten.join("\t") }
+    def report(list, file)
+      File.open(log_path(file), 'w') do |f|
+        list
+          .select { |_, _, flags| flags.any? }
+          .map { |c, q, flags| [c, q, flags.map { |flg| f_to_s(flg) }] }
+          .sort
+          .each { |args| f.puts args.flatten.join("\t") }
+      end
     end
 
     def f_to_s(f)
@@ -49,8 +59,12 @@ end
 
 namespace :regression do
   desc 'checks page parse result'
-  task :check_parse, ['flags'] do |_, args|
-    flags = args[:flags]
-    AtCoderFriends::Regression.check_parse flags
+  task :check_parse do
+    AtCoderFriends::Regression.check_parse
+  end
+
+  desc 'checks binary problem parse result'
+  task :check_bin do
+    AtCoderFriends::Regression.check_bin
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: at_coder_friends
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - nejiko96
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2019-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -140,6 +140,7 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -186,6 +187,7 @@ files:
 - lib/at_coder_friends/version.rb
 - tasks/regression/check_const.rake
 - tasks/regression/check_diff.rake
+- tasks/regression/check_fmt.rake
 - tasks/regression/check_parse.rake
 - tasks/regression/regression.rb
 - tasks/regression/section_list.rake
@@ -197,7 +199,10 @@ files:
 homepage: https://github.com/nejiko96/at_coder_friends
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/nejiko96/at_coder_friends
+  source_code_uri: https://github.com/nejiko96/at_coder_friends
+  changelog_uri: https://github.com/nejiko96/at_coder_friends/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths: