gettc 1.10 → 2.0

data/core/lib/gettc/print.rb

@@ -1,56 +0,0 @@
-require "gettc/problem"
-require "rdiscount"
-
-module Gettc
-    class Problem
-        def to_md
-            out  = "# [#{@name}](#{@url})\n"
-            out << "*#{@source}*\n\n"
-
-            out << "## Statement\n"
-            out << @statement << "\n\n"
-
-            unless @definitions.empty? then
-                out << "## Definitions\n"
-                @definitions.each do |k, v| out << "- *#{k}*: `#{v}`\n" end 
-                out << "\n"
-            end 
-
-            unless @notes.empty? then
-                out << "## Notes\n"
-                @notes.each do |note| out << "- #{note}\n" end 
-                out << "\n"
-            end 
-
-            unless @constraints.empty? then
-                out << "## Constraints\n"
-                @constraints.each do |constraint|
-                    out << "- #{constraint}\n"
-                end 
-                out << "\n"
-            end 
-
-            unless @examples.empty? then
-                out << "## Examples\n"
-                @examples.each_index do |i|
-                    example = @examples[i]
-                    out << "### Example #{i + 1}\n"
-                    out << "#### Input\n<c>"
-                    out << example.input.gsub("\n", "<br />")
-                    out << "</c>\n"
-                    out << "#### Output\n<c>"
-                    out << example.output.gsub("\n", "<br />")
-                    out << "</c>\n"
-                    unless example.reason.empty? then
-                        out << "#### Reason\n#{example.reason}\n\n"
-                    end 
-                end
-            end 
-            return out
-        end
-        def to_html
-            markdown = RDiscount.new to_md
-            return markdown.to_html
-        end
-    end
-end

data/core/lib/gettc/problem.rb

@@ -1,33 +0,0 @@
-module Gettc
-    class Case
-        attr_accessor :input, :output, :reason
-        def initialize
-            @input = ""
-            @output = ""
-            @reason = ""
-        end
-    end
-    class Image
-        attr_accessor :name, :content
-        def initialize
-            @name = ""
-            @content = ""
-        end
-    end
-    class Problem
-        attr_accessor :name, :url, :source, :statement, :definitions, :notes, 
-                      :constraints, :examples, :systests, :images
-        def initialize
-            @name = ""
-            @url = ""
-            @source = ""
-            @statement = ""
-            @definitions = { }
-            @notes = []
-            @constraints = []
-            @examples = []
-            @systests = []
-            @images = []
-        end       
-    end
-end

data/core/lib/gettc/signature.rb

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

data/core/lib/gettc/types.rb

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

data/core/lib/version.rb

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

data/core/test/gettc/download_test.rb

@@ -1,29 +0,0 @@
-require "test/unit" 
-require "gettc/download" 
-include Gettc
-
-class DownloadTest < Test::Unit::TestCase
-    def setup
-        @account = Account.new "gettc", "algorithm"
-    end
-    def test_wrong_account
-        assert_raises LoginFailed do 
-            Downloader.new Account.new "username", "password"
-        end
-    end    
-    def test_wrong_id
-        assert_raises IDNotAvailable do 
-            (Downloader.new @account).download_problem 1000000
-        end
-    end
-    def test_download_ok
-        ids = [10297, 10324, 10329, 10330, 10505, 10685, 10686, 10690, 11264,
-               11266, 11303, 11315, 11322, 11350, 11357, 11419, 8763, 8819, 9995]
-        downloader = Downloader.new @account
-        3.times do
-            id = ids[rand ids.size]
-            html = downloader.download_problem id
-            assert_match "<h3>Problem Statement</h3>", html
-        end
-    end
-end

data/core/test/gettc/generate_test.rb

@@ -1,31 +0,0 @@
-require "test/unit" 
-require "fileutils"
-require "tmpdir"
-
-require "gettc/generate" 
-include Gettc
-
-class GenerateTest < Test::Unit::TestCase
-    def setup
-        @source_d = File.join File.dirname(__FILE__), "../../dist"
-        @target_d = File.join Dir.tmpdir, "gettc"
-        FileUtils.mkdir @target_d unless File.directory? @target_d
-        @generator = Generator.new @source_d, @target_d
-    end
-    def test_initialize
-        assert_raise SourceDirNotExist do 
-            Generator.new "this_directory_must_not_exist", @target_d
-        end
-        assert_raise TargetDirNotExist do 
-            Generator.new @source_d, "this_directory_must_not_exist"
-        end
-    end
-    def test_prob_dir_exists
-        prob = Problem.new
-        prob.name = "JustATest"
-        prob_d = File.join @target_d, prob.name
-        FileUtils.mkdir prob_d unless File.exists? prob_d
-        assert_raise ProblemDirExists do @generator.generate prob end
-        FileUtils.rmdir prob_d
-    end
-end

data/core/test/gettc/parse_test.rb

@@ -1,104 +0,0 @@
-require "test/unit" 
-require "gettc/parse" 
-include Gettc
-
-class ParseTest < Test::Unit::TestCase
-    def setup
-        downloader = Downloader.new Account.new "gettc", "algorithm"
-        @parser = Parser.new downloader
-        @data_d = File.join File.dirname(__FILE__), "../../temp/download_problem_statement"
-    end
-    def get_problem_raw prob
-        return File.read File.join @data_d, prob + ".htm"
-    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
-        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_PageNumbers
-        html = get_problem_raw "PageNumbers"
-        prob = @parser.parse html
-        assert_equal "PageNumbers", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 1, prob.notes.size
-        assert_equal 1, prob.constraints.size
-        assert_equal 5, prob.examples.size
-        assert_equal 118, prob.systests.size
-        assert_equal 0, prob.images.size
-    end
-    def test_CirclesCountry
-        html = get_problem_raw "CirclesCountry"
-        prob = @parser.parse html
-        assert_equal "CirclesCountry", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 0, prob.notes.size
-        assert_equal 7, prob.constraints.size
-        assert_equal 5, prob.examples.size
-        assert_equal 228, prob.systests.size
-        assert_equal 4, prob.images.size
-    end
-    def test_TheTournamentDivOne
-        html = get_problem_raw "TheTournamentDivOne"
-        prob = @parser.parse html
-        assert_equal "TheTournamentDivOne", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 0, prob.notes.size
-        assert_equal 4, prob.constraints.size
-        assert_equal 4, prob.examples.size
-        assert_equal 0, prob.systests.size
-        assert_equal 0, prob.images.size
-    end
-    def test_FunnyGames
-        html = get_problem_raw "FunnyGames"
-        prob = @parser.parse html
-        assert_equal "FunnyGames", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 0, prob.notes.size
-        assert_equal 6, prob.constraints.size
-        assert_equal 5, prob.examples.size
-        assert_equal 0, prob.systests.size
-        assert_equal 0, prob.images.size
-    end
-    def test_BuildingRoads
-        html = get_problem_raw "BuildingRoads"
-        prob = @parser.parse html
-        assert_equal "BuildingRoads", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 2, prob.notes.size
-        assert_equal 10, prob.constraints.size
-        assert_equal 5, prob.examples.size
-        assert_equal 0, prob.systests.size
-        assert_equal 2, prob.images.size
-    end
-    def test_Acronyms
-        html = get_problem_raw "Acronyms"
-        prob = @parser.parse html
-        assert_equal "Acronyms", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 1, prob.notes.size
-        assert_equal 8, prob.constraints.size
-        assert_equal 8, prob.examples.size
-        assert_equal 39, prob.systests.size
-        assert_equal 0, prob.images.size
-    end
-    def test_BackyardTrees
-        html = get_problem_raw "BackyardTrees"
-        prob = @parser.parse html
-        assert_equal "BackyardTrees", prob.name
-        assert_equal 5, prob.definitions.size
-        assert_equal 0, prob.notes.size
-        assert_equal 4, prob.constraints.size
-        assert_equal 6, prob.examples.size
-        assert_equal 2, prob.images.size
-    end
-end

data/core/test/gettc/signature_test.rb

@@ -1,54 +0,0 @@
-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