gettc 1.10 → 2.0

data/lib/gettc/signature.rb

@@ -0,0 +1,63 @@
+require "gettc/types"
+
+module Gettc
+  class SignatureError < StandardError
+  end
+
+  class CannotParseSignature < SignatureError
+    attr_accessor :source
+
+    def initialize(source, message = "Cannot parse signature")
+      @source = source
+      super "#{message}: (#{source}"
+    end
+  end
+
+  class InvalidVariableName < SignatureError
+    attr_accessor :name
+
+    def initialize(name, message = "Invalid variable name")
+      @name = name
+      super "#{message} (#{name})"
+    end
+  end
+
+  class Signature
+    attr_accessor :type, :name
+
+    def initialize(type, name)
+      @type = type
+      @name = name
+    end
+  end
+
+  def parse_signature(str)
+    str.strip!
+
+    parts = str.split
+    raise CannotParseSignature.new(str) unless parts.size == 2
+
+    type = parse_type(parts[0])
+    name = parts[1]
+
+    raise InvalidVariableName.new(name) unless name =~ /^[a-zA-Z_]\w*$/
+    Signature.new(type, name)
+  end
+
+  def parse_method_signature(str)
+    str.strip!
+
+    sigs = []
+
+    parts = str.split("(")
+    raise CannotParseSignature.new(str) unless parts.size == 2
+    sigs << parse_signature(parts[0])
+
+    str = parts[1]
+    raise CannotParseSignature.new(str) unless str[-1] == ")"
+
+    str.chop.split(",").each { |sig| sigs << parse_signature(sig) }
+
+    sigs
+  end
+end

data/lib/gettc/types.rb

@@ -0,0 +1,93 @@
+module Gettc
+  TypeError = Class.new(StandardError)
+
+  class UnsupportedType < TypeError
+    attr_accessor :type
+
+    def initialize(type = nil, message = "Not a valid TopCoder type")
+      @type = type
+      super "#{message}: (#{type})"
+    end
+  end
+
+  class Type
+    def initialize(is_object)
+      @is_object = is_object
+    end
+
+    def obj?
+      @is_object
+    end
+
+    def to_s
+      return "#{subtype}[]" if self.is_a?(TArray)
+
+      case self
+      when TInt
+        "int"
+      when TLong
+        "long"
+      when TFloat
+        "float"
+      when TDouble
+        "double"
+      when TChar
+        "char"
+      when TString
+        "String"
+      when TBoolean
+        "boolean"
+      else
+        "unknown"
+      end
+    end
+  end
+
+  TBoolean = Type.new(false)
+  TInt = Type.new(false)
+  TLong = Type.new(false)
+  TFloat = Type.new(false)
+  TDouble = Type.new(false)
+  TChar = Type.new(false)
+  TString = Type.new(true)
+
+  class TArray < Type
+    attr_accessor :subtype
+
+    def initialize(subtype)
+      raise UnsupportedType.new(subtype) unless subtype.is_a?(Type)
+      @subtype = subtype
+    end
+
+    def ==(ary)
+      ary.is_a?(TArray) && @subtype == ary.subtype
+    end
+
+    def obj?
+      true
+    end
+  end
+
+  def parse_type(str)
+    return TArray.new(parse_type(str[0 .. -3])) if str[-2 .. -1] == "[]"
+
+    case str
+    when "boolean"
+      TBoolean
+    when "int"
+      TInt
+    when "long"
+      TLong
+    when "float"
+      TFloat
+    when "double"
+      TDouble
+    when "char"
+      TChar
+    when "String"
+      TString
+    else
+      raise UnsupportedType.new(str)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Gettc
+  VERSION = "2.0"
+end

data/test/gettc/download_test.rb

@@ -0,0 +1,61 @@
+require "test_helper"
+require "gettc/download"
+
+class DownloadTest < Test::Unit::TestCase
+  def setup
+    @downloader = Downloader.new($account)
+  end
+
+  def teardown
+    Dir.glob("gettc_http_response*.html").each { |filename| File.delete(filename) }
+  end
+
+  def test_wrong_account
+    assert_raises AuthTokenError do
+      Downloader.new(Account.new("username", "password"))
+    end
+  end
+
+  def test_download_statement
+    $problems.each do |hash|
+      html = @downloader.download_statement(hash["id"])
+      assert_match "<h3>Problem Statement</h3>", html, hash["message"]
+      write_problem_html(:statement, hash["name"], html)
+    end
+  end
+
+  def test_download_statement_wrong_problem_id
+    assert_raises IDNotAvailable do
+      @downloader.download_statement(1000000)
+    end
+  end
+
+  def test_download_detail
+    $problems.each do |hash|
+      html = @downloader.download_detail(hash["id"], hash["round_id"])
+      assert_match "Problem Detail", html, hash["message"]
+      write_problem_html(:detail, hash["name"], html)
+    end
+  end
+
+  def test_download_detail_wrong_round_id
+    assert_raises HttpError do
+      @downloader.download_detail(10297, 1000000)
+    end
+  end
+
+  def test_download_solution
+    $problems.each do |hash|
+      next unless hash["solution_id"]
+      html = @downloader.download_solution(hash["id"], hash["round_id"], hash["solution_id"])
+      assert_match "TopCoder Statistics - Problem Solution", html, hash["message"]
+      write_problem_html(:solution, hash["name"], html)
+    end
+  end
+
+  def test_download_solution_wrong_solution_id
+    assert_raises BadResponseError do
+      @downloader.download_solution(10297, 13751, 1000000)
+    end
+  end
+end

data/test/gettc/generate_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+require "gettc/generate"
+require "fileutils"
+
+class GenerateTest < Test::Unit::TestCase
+  def setup
+    script_dir = File.dirname(__FILE__)
+
+    @source_dir = File.join(script_dir, "../../dist")
+    raise "#{@source_dir} not found. Consider running `rake dist` first." unless File.exists?(@source_dir)
+
+    @target_dir = File.join(script_dir, "../data/generated")
+    FileUtils.mkdir(@target_dir) unless File.directory?(@target_dir)
+
+    @generator = Generator.new(@source_dir, @target_dir)
+  end
+
+  def test_initialize
+    dump_name = "this_directory_must_not_exist"
+    assert_raise SourceDirNotExist do Generator.new(dump_name, @target_dir) end
+    assert_raise TargetDirNotExist do Generator.new(@source_dir, dump_name) end
+  end
+
+  def test_problem_dir_exists
+    problem = Problem.new
+    problem.name = "JustATest"
+
+    problem_dir = File.join(@target_dir, problem.name)
+    FileUtils.mkdir(problem_dir) unless File.exists?(problem_dir)
+
+    assert_raise ProblemDirExists do @generator.generate(problem) end
+    FileUtils.rmdir problem_dir
+  end
+
+  def test_generate_problems
+    $problems.each do |hash|
+      @problem = hash
+
+      begin
+        @generator.generate(read_problem_yaml(@problem["name"]))
+      rescue ProblemDirExists
+        puts "Skipped generating #{@problem['name']} because it's already generated."
+      end
+
+      assert_equal hash["images_count"], count_files("prob/images")
+      assert_equal 2 * hash["examples_count"], count_files("data/demo")
+      assert_equal 2 * hash["systests_count"], count_files("data/sys")
+
+      assert_file_exists "util/check/check.cpp"
+      assert_file_exists "util/check/Makefile"
+
+      assert_file_exists "bin/runner.rb"
+      assert_file_exists "bin/runner.sh"
+
+      assert_file_exists "prob/#{@problem['name']}.html"
+      assert_file_exists "prob/#{@problem['name']}.md"
+    end
+  end
+
+  private
+
+  def count_files(subdir)
+    full_path = File.join(@target_dir, @problem["name"], subdir)
+    Dir.new(full_path).entries.reject { |name| [".", ".."].include?(name) }.size
+  end
+
+  def assert_file_exists(filename)
+    assert File.exists?(File.join(@target_dir, @problem["name"], filename))
+  end
+end

data/test/gettc/parse_test.rb

@@ -0,0 +1,78 @@
+require "test_helper"
+require "gettc/parse"
+
+class FakeDownloader
+  def initialize(problem_name = nil)
+    @problem_name = problem_name
+  end
+
+  def download(url)
+    "ImageContent"
+  end
+
+  def download_statement(problem_id)
+    read_problem_html(:statement, @problem_name)
+  end
+
+  def download_detail(problem_id, round_id)
+    read_problem_html(:detail, @problem_name)
+  end
+
+  def download_solution(problem_id, round_id, solution_id)
+    read_problem_html(:solution, @problem_name)
+  end
+
+end
+
+class ParseTest < Test::Unit::TestCase
+  def test_get_param_value
+    assert_equal 13751, Parser.send(:get_param_value,
+      "/tc?module=ProblemDetail&rd=13751&pm=10297", "rd").to_i
+    assert Parser.send(:get_param_value,
+      "/tc?module=ProblemDetail&rd=13751&pm=10297", "cr").nil?
+    assert_equal 22717415, Parser.send(:get_param_value,
+      "/stat?c=problem_solution&amp;cr=22717415&amp;rd=13751&amp;pm=10297", "cr").to_i
+  end
+
+  def test_indexes
+    assert_equal [0, 3], Parser.send(:indexes, "abcde", "bc")
+    assert_equal nil, Parser.send(:indexes, "abcde", "f")
+  end
+
+  def test_filter
+    parser = Parser.new(FakeDownloader.new(nil))
+
+    assert_equal "Lorem Ipsum", parser.send(:filter, "<xml>   Lorem Ipsum  </xml> ")
+    assert_equal "2^(3)", parser.send(:filter, "2<sup>3</sup>")
+    assert_equal "*hi*", parser.send(:filter, "   <b>hi</b>")
+
+    html = <<-END
+      <img src=
+      "http://www.topcoder.com/contest/problem/CirclesCountry/case1.gif">
+    END
+    assert_equal "![image](images/case1.gif)", parser.send(:filter, html)
+  end
+
+  def test_parse_problems
+    $problems.each do |hash|
+      downloader = FakeDownloader.new(hash["name"])
+      problem = Parser.new(downloader).parse(hash["id"])
+
+      assert_equal hash["name"], problem.name, hash["message"]
+      assert_equal hash["source"], problem.source, hash["message"]
+      assert_equal hash["definitions_count"], problem.definitions.size, hash["message"]
+      assert_equal hash["notes_count"], problem.notes.size, hash["message"]
+      assert_equal hash["contraints_count"], problem.constraints.size, hash["message"]
+      assert_equal hash["examples_count"], problem.examples.size, hash["message"]
+      assert_equal hash["systests_count"], problem.systests.size, hash["message"]
+      assert_equal hash["images_count"], problem.images.size, hash["message"]
+
+      (problem.examples + problem.systests).each do |test_case|
+        assert !test_case.input.empty?
+        assert !test_case.output.empty?
+      end
+
+      write_problem_yaml(problem)
+    end
+  end
+end

data/test/gettc/signature_test.rb

@@ -0,0 +1,71 @@
+require "test/unit"
+require "gettc/signature"
+include Gettc
+
+class SignatureTest < Test::Unit::TestCase
+  def test_parse_signature
+    assert_raise CannotParseSignature do
+      parse_signature("invalid_signature")
+    end
+
+    assert_raise UnsupportedType do
+      parse_signature("strange_type name")
+    end
+
+    assert_raise InvalidVariableName do
+      parse_signature("int not&ok&name")
+    end
+
+    assert_raise InvalidVariableName do
+      parse_signature("int 0zero")
+    end
+
+    sig = parse_signature("String[] a_valid_nam3")
+    assert_equal TArray.new(TString), sig.type
+    assert_equal "a_valid_nam3", sig.name
+  end
+
+  def test_parse_method_signature
+    assert_raise CannotParseSignature do
+      parse_method_signature("there are no brackets")
+    end
+
+    assert_raise CannotParseSignature do
+      parse_method_signature("int main(int main())")
+    end
+
+    assert_raise CannotParseSignature do
+      parse_method_signature("int main(oops forget to close bracket")
+    end
+
+    method  =  "  int leastBorders(String[] X  , int[] Y, double[] R,"
+    method += "  char my_x1,   long y1  ,  float x2, int[][] y2) "
+    sigs = parse_method_signature(method)
+
+    assert_equal 8, sigs.size
+
+    assert_equal TInt, sigs[0].type
+    assert_equal "leastBorders", sigs[0].name
+
+    assert_equal TArray.new(TString), sigs[1].type
+    assert_equal "X", sigs[1].name
+
+    assert_equal TArray.new(TInt), sigs[2].type
+    assert_equal "Y", sigs[2].name
+
+    assert_equal TArray.new(TDouble), sigs[3].type
+    assert_equal "R", sigs[3].name
+
+    assert_equal TChar, sigs[4].type
+    assert_equal "my_x1", sigs[4].name
+
+    assert_equal TLong, sigs[5].type
+    assert_equal "y1", sigs[5].name
+
+    assert_equal TFloat, sigs[6].type
+    assert_equal "x2", sigs[6].name
+
+    assert_equal TArray.new(TArray.new(TInt)), sigs[7].type
+    assert_equal "y2", sigs[7].name
+  end
+end

data/test/gettc/types_test.rb

@@ -0,0 +1,31 @@
+require "test/unit"
+require "gettc/types"
+include Gettc
+
+class TypesTest < Test::Unit::TestCase
+  def test_parse_type
+    assert_raise UnsupportedType do TArray.new(123) end
+    assert_raise UnsupportedType do parse_type("") end
+    assert_raise UnsupportedType do parse_type(" ") end
+    assert_raise UnsupportedType do parse_type("[]") end
+    assert_raise UnsupportedType do parse_type("vector") end
+    assert_raise UnsupportedType do parse_type("vector[]") end
+
+    assert_equal TBoolean, parse_type("boolean")
+    assert_equal TInt, parse_type("int")
+    assert_equal TLong, parse_type("long")
+    assert_equal TFloat, parse_type("float")
+    assert_equal TDouble, parse_type("double")
+    assert_equal TChar, parse_type("char")
+    assert_equal TString, parse_type("String")
+
+    assert_equal TArray.new(TBoolean), parse_type("boolean[]")
+    assert_equal TArray.new(TInt), parse_type("int[]")
+    assert_equal TArray.new(TArray.new(TString)), parse_type("String[][]")
+  end
+
+  def test_type_to_s
+    assert_equal "String", TString.to_s
+    assert_equal "boolean[][]", TArray.new(TArray.new(TBoolean)).to_s
+  end
+end