gettc 1.9 → 1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65b3906b3f1f4b5bda986b7134f8cb8e5ca12206
-  data.tar.gz: 92ae49546cf3188d71ec91ace589a7f854ffa38c
+  metadata.gz: be356b29f63fbb870ee7ffca99f1bcc3d0bcd52e
+  data.tar.gz: 47c2abcafbe216880d20d01a6d11c0731bda6c66
 SHA512:
-  metadata.gz: af342b43c1c2638f604f11a65c8450808fabb7ea187a9807d7f1d5465607f2f5848324a2a23ed69a4b04118b6aa534cf0dac325f0c2b39ba440658dcefbafd77
-  data.tar.gz: 72621691d2e5f6c22d7c3eeb9d951748d3463a15715e4135b8867c9e96850b3ae556a5dfd3e912868fe7b56b482385864f0427de9c4286eecc05b5a1519b47fd
+  metadata.gz: 2e057827784adaa9d9f2e8b55c299f0a3e67aa72945409d5540fd610a38168819c2e960af5f6a3d9c6065c9947e377b2e58fcd98419498cd686ae8bf2b5b2f4f
+  data.tar.gz: 7c2bcb3dd3f338056b204f2d4f3d0505b949b7f58616a1bb5adbec67c1c21a2ef9e290b090658f6494feb1a04356c555fcce82b6fcea7d38db5e496d1b2d433b

data/core/lib/gettc/types.rb

@@ -1,6 +1,6 @@
 module Gettc
     TypeError = Class.new StandardError        
-    class UnrecognizedType < TypeError
+    class UnsupportedType < TypeError
         attr_accessor :type
         def initialize type = nil, msg = "Not a valid TopCoder type"
             @type = type
@@ -49,7 +49,7 @@ module Gettc
     class TArray < Type
         attr_accessor :subtype
         def initialize subtype
-            raise UnrecognizedType.new subtype unless subtype.is_a? Type
+            raise UnsupportedType.new subtype unless subtype.is_a? Type
             @subtype = subtype
         end
         def == ary
@@ -78,6 +78,6 @@ module Gettc
         when "String"
             return TString
         end
-        raise UnrecognizedType.new str
+        raise UnsupportedType.new str
     end
 end

data/core/lib/version.rb

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

data/core/test/gettc/signature_test.rb

@@ -7,7 +7,7 @@ class SignatureTest < Test::Unit::TestCase
         assert_raise CannotParseSignature do 
             parse_signature "invalid_signature" 
         end
-        assert_raise UnrecognizedType do 
+        assert_raise UnsupportedType do 
             parse_signature "strange_type name" 
         end
         assert_raise InvalidVariableName do 

data/core/test/gettc/types_test.rb

@@ -4,12 +4,12 @@ include Gettc
 
 class TypesTest < Test::Unit::TestCase
     def test_parse_type
-        assert_raise UnrecognizedType do array = TArray.new 123 end
-        assert_raise UnrecognizedType do type = parse_type "" end
-        assert_raise UnrecognizedType do type = parse_type " " end
-        assert_raise UnrecognizedType do type = parse_type "[]" end       
-        assert_raise UnrecognizedType do type = parse_type "vector" end       
-        assert_raise UnrecognizedType do type = parse_type "vector[]" end       
+        assert_raise UnsupportedType do array = TArray.new 123 end
+        assert_raise UnsupportedType do type = parse_type "" end
+        assert_raise UnsupportedType do type = parse_type " " end
+        assert_raise UnsupportedType do type = parse_type "[]" end       
+        assert_raise UnsupportedType do type = parse_type "vector" end       
+        assert_raise UnsupportedType do type = parse_type "vector[]" end       
         assert_equal TBoolean, parse_type("boolean")
         assert_equal TInt, parse_type("int")
         assert_equal TLong, parse_type("long")

data/dist/config.yml

@@ -1,3 +1,3 @@
 username: gettc
 password: algorithm
-version: 1.9
+version: 1.10

data/dist/include/javascript/engine.rb

@@ -0,0 +1,38 @@
+require "gettc/types"
+
+module Gettc
+    class Type
+        def dumb_javascript
+            if is_a? TArray then
+                return "[]"
+            end
+
+            case self
+            when TInt, TLong, TFloat, TDouble
+                return "0"
+            when TChar
+                return "'$'"
+            when TString
+                return '"$"'
+            when TBoolean
+                return "true"
+            end
+
+            return "null"
+        end
+    end
+    class JavascriptEngine
+        attr_reader :arglist, :input
+        def initialize func, vars
+            temp = vars.map do |var|
+                var.name
+            end
+            @arglist = temp.join ", "
+
+            temp = vars.map do |var| 
+                "var " + var.name + ' = reader.next("' + var.type.to_s + '");'
+            end
+            @input = temp.join " reader.next();\n"
+        end
+    end
+end

data/dist/include/javascript/topcoder.js

@@ -0,0 +1,7 @@
+var errors = require("./topcoder/errors");
+
+module.exports = {
+    Reader : require("./topcoder/reader"),
+    Writer : require("./topcoder/writer"),
+    UnsupportedType : errors.UnsupportedType
+};

data/dist/include/javascript/topcoder/errors.js

@@ -0,0 +1,7 @@
+exports.UnsupportedType = function(type) {
+    this.type = type;
+    this.toString = function() {
+        return "UnsupportedType: " + 
+               type.toString() + " is not a valid TopCoder type";
+    };
+}

data/dist/include/javascript/topcoder/reader.js

@@ -0,0 +1,239 @@
+var tc = require("./errors");
+
+function ParseError(text, pos, info) {
+    if (pos < text.length && pos >= 0) {
+        text = text.substr(0, pos) + "|" + 
+               text.substr(pos, 1) + "|" +
+               text.substr(pos + 1);
+    }
+    this.message = "<" + text + ">";
+    if (typeof(info) === "string") {
+        this.message += " (" + info + ")";
+    }
+
+    this.toString = function() {
+        return "ParseError: " + this.message;
+    };
+}
+
+
+function Reader(text) {
+    this.text = text;
+    this.pos = 0;
+    this.len = text.length;
+}
+
+Reader.prototype.next = function(type) {
+    if (typeof(type) === "undefined") {
+        spaces.call(this);
+        expect.call(this, ',');
+        return ;
+    }
+    if (type.substr(type.length - 2, 2) === "[]") {
+        return nextArray.call(this, type.substr(0, type.length - 2));
+    }
+    switch (type) {
+        case "boolean":
+            return nextBoolean.call(this);
+        case "int":
+            return nextInt32.call(this);
+        case "long":
+            return nextInt64.call(this);
+        case "float":
+        case "double":
+            return nextFloat.call(this);
+        case "char":
+            return nextChar.call(this);
+        case "String":
+            return nextString.call(this);
+        default:
+            throw new tc.UnsupportedType(type);
+    }
+};
+
+
+function isWhiteSpace() {
+    var c = this.text.charAt(this.pos);
+    return c === ' ' || c === '\t' || c === '\n';
+}
+
+function isDigit(c) {
+    var c = this.text.charAt(this.pos);
+    return c >= '0' && c <= '9';
+}
+
+
+function raiseHere(message) {
+    throw new ParseError(this.text, this.pos, message);
+}
+
+function checkPos() {
+    if (this.pos >= this.len) {
+        raiseHere.call(this, "unexpected end of input");
+    }
+}
+
+
+function token() {
+    checkPos.call(this);
+    return this.text.charAt(this.pos);
+}
+
+function spaces() {
+    while (this.pos < this.len && isWhiteSpace.call(this)) {
+        this.pos += 1;
+    }
+}
+
+function expect(character) {
+    if (token.call(this) === character) {
+        this.pos += 1;
+    } else {
+        raiseHere(this, "expecting <" + character + ">");
+    }
+}
+
+
+function nextBoolean() {
+    spaces.call(this);
+    if (this.text.substr(this.pos, 4).toUpperCase() === "TRUE") {
+        this.pos += 4;
+        return true;
+    } else if (this.text.substr(this.pos, 5).toUpperCase() === "FALSE") {
+        this.pos += 5;
+        return false;
+    }
+    raiseHere.call(this, "expecting either true or false");
+}
+
+
+function nextDigits() {
+    checkPos.call(this);
+    if (!isDigit.call(this)) {
+        raiseHere.call(this, "expecting a digit");
+    }
+    var start = this.pos;
+    while (true) {
+        this.pos += 1;
+        if (this.pos === this.len || !isDigit.call(this)) {
+            break;
+        }
+    }
+    return this.text.substr(start, this.pos - start);
+}
+
+
+function nextNaturalNumber(parser) {
+    spaces.call(this);
+    if (token.call(this) === "-") {
+        this.pos += 1;
+        return -parser(nextDigits.call(this));
+    }
+    return parser(nextDigits.call(this));
+}
+
+function nextInt32() {
+    return nextNaturalNumber.call(this, function (str) {
+        return parseInt(str, 10);
+    });
+}
+
+function nextInt64() {
+    var Int64 = require("long");
+    return nextNaturalNumber.call(this, function (str) {
+        return Int64.fromString(str);
+    });
+}
+
+
+function nextPositiveFloat() {
+    var str = nextDigits.call(this);
+    if (this.pos < this.len) {
+        if (this.text.charAt(this.pos) === '.') {
+            this.pos += 1;
+            str += "." + nextDigits.call(this);
+        }
+    }
+    return parseFloat(str);
+}
+
+function nextFloat() {
+    spaces.call(this);
+    if (token.call(this) === '-') {
+        this.pos += 1;
+        return -nextPositiveFloat.call(this);
+    }
+    return nextPositiveFloat.call(this);
+}
+
+
+function nextChar() {
+    spaces.call(this);
+    var c = token.call(this);
+    if (c === '\'') {
+        this.pos += 1;
+        var ret = token.call(this);
+        this.pos += 1;
+        expect.call(this, '\'');
+        return ret;
+    }
+    this.pos += 1;
+    return c;
+}
+
+
+function nextString() {
+    spaces.call(this);
+    expect.call(this, '"');
+    var start = this.pos;
+    while (true) {
+        if (this.pos >= this.len) {
+            raiseHere.call(this, "expecting a closing quote");
+        }
+        if (token.call(this) === '"') {
+            this.pos += 1;
+            var saved = this.pos;
+            spaces.call(this);
+            if (this.pos === this.len || 
+                this.text.charAt(this.pos) === ',' ||
+                this.text.charAt(this.pos) === ']') {
+                this.pos = saved;                
+                return this.text.substr(start, this.pos - 1 - start);
+            }
+        } else {
+            this.pos += 1;
+        }
+    }
+}
+
+
+function nextElems(elemType, arr) {
+    spaces.call(this);
+    var c = token.call(this);
+    if (c === ']') {
+        this.pos += 1;
+        return ;
+    } else if (c === ',') {
+        this.pos += 1;
+        arr.push(this.next(elemType));
+        nextElems.call(this, elemType, arr);
+        return ;
+    }
+    raiseHere("expecting either <,> or <]>");
+}
+
+function nextArray(elemType) {
+    var arr = [];
+    spaces.call(this);
+    expect.call(this, '[');
+    spaces.call(this);
+    if (token.call(this) === ']') {
+        this.pos += 1;
+        return arr;
+    }
+    arr.push(this.next(elemType));
+    nextElems.call(this, elemType, arr);
+    return arr;
+}
+
+module.exports = Reader;

data/dist/include/javascript/topcoder/writer.js

@@ -0,0 +1,46 @@
+var tc = require("./errors");
+
+function Writer() {
+    this.text = "";
+}
+
+Writer.prototype.next = function(value, type) {
+    if (typeof(value) === "undefined") {
+        this.text += ", "
+        return this;
+    }
+    if (type.substr(type.length - 2, 2) === "[]") {
+        var elemType = type.substr(0, type.length - 2);
+        this.text += '[';
+        for (var i = 0; i < value.length; ++i) {
+            this.next(value[i], elemType);
+            if (i < value.length - 1) {
+                this.next();
+            }
+        }
+        this.text += ']';
+        return this;
+    }
+    switch (type) {
+        case "boolean":
+        case "int":
+        case "long":
+        case "float":
+        case "double":
+            this.text += value.toString();
+            return this;
+        case "char":
+            this.text += "'" + value + "'";
+            return this;
+        case "String":
+            this.text += '"' + value + '"';
+            return this;
+    }
+    throw new tc.UnsupportedType(type);
+};
+
+Writer.prototype.toString = function() {
+    return this.text;
+};
+
+module.exports = Writer;

data/dist/include/python/engine.rb

@@ -3,7 +3,7 @@ require "gettc/types"
 module Gettc
     class Type
         def dumb_python
-            if self.is_a? TArray then
+            if is_a? TArray then
                 return "[]"
             end
 

data/dist/include/python/topcoder/__init__.py

@@ -1,3 +1,3 @@
-from topcoder.errors import UnsupportedTypeError
-from topcoder.reader import ReadError, Reader
-from topcoder.writer import write
+from topcoder.errors import UnsupportedType
+from topcoder.reader import ParseError, Reader
+from topcoder.writer import write

data/dist/include/python/topcoder/errors.py

@@ -1,4 +1,4 @@
-class UnsupportedTypeError(Exception):
+class UnsupportedType(Exception):
     def __init__(self, type):
         message = type + " is not a valid TopCoder type"
         Exception.__init__(self, message)

data/dist/include/python/topcoder/reader.py

@@ -1,6 +1,6 @@
-from topcoder.errors import UnsupportedTypeError
+from topcoder.errors import UnsupportedType
 
-class ReadError(Exception):
+class ParseError(Exception):
     def __init__(self, text, pos, info = ""):
         if (pos < len(text)) and (pos >= 0):
             text = text[:pos] + "|" + text[pos] + "|" + text[(pos + 1):]
@@ -41,10 +41,10 @@ class ReaderInternal(object):
         if type.endswith("[]"):
             return self.next_array(type[:-2])
         
-        raise UnsupportedTypeError(type)
+        raise UnsupportedType(type)
 
     def raise_here(self, message):
-        raise ReadError(self.text, self.pos, message)
+        raise ParseError(self.text, self.pos, message)
 
     def check_pos(self):
         if self.pos >= self.len:

data/dist/include/python/topcoder/writer.py

@@ -1,4 +1,4 @@
-from topcoder.errors import UnsupportedTypeError
+from topcoder.errors import UnsupportedType
 
 def write(value, type):
     if type in ["int", "long", "float", "double", "boolean"]:
@@ -10,4 +10,4 @@ def write(value, type):
     elif type.endswith("[]"):
         elem_type = type[:-2]
         return "[" + ", ".join(map(lambda elem: write(elem, elem_type), value)) + "]"
-    raise UnsupportedTypeError(type)
+    raise UnsupportedType(type)

data/dist/include/ruby/topcoder/reader.rb

@@ -6,7 +6,7 @@ module TopCoder
         def initialize text, pos, info = ""
             message = text
             if pos < text.size && pos >= 0
-                message = text[0..pos]
+                message = pos == 0 ? "" : text[0..(pos - 1)]
                 message << "|"
                 message << text[pos]
                 message << "|"
@@ -53,7 +53,7 @@ module TopCoder
                 end
             end
 
-            raise UnrecognizedType.new typ
+            raise UnsupportedType.new typ
         end
 
     private

data/dist/include/ruby/topcoder/writer.rb

@@ -7,11 +7,23 @@ module TopCoder
             @text = ""
         end
         def next value = nil, typ = nil
-            if value.nil? && typ.nil?
+            if value.nil? || typ.nil?
                 @text << ", "
-                return
+                return self
             end 
 
+            if typ.is_a? TArray
+                @text << ?[
+                value.each_index do |i|
+                    self.next value[i], typ.subtype
+                    if i < value.size - 1
+                        self.next
+                    end 
+                end
+                @text << ?]
+                return self
+            end
+
             case typ
             when TBoolean, TInt, TLong, TFloat, TDouble
                 @text << value.to_s
@@ -20,19 +32,10 @@ module TopCoder
             when TString
                 @text << ?" << value << ?"
             else 
-                if typ.is_a? TArray
-                    @text << ?[
-                    value.each_index do |i|
-                        self.next value[i], typ.subtype
-                        if i < value.size - 1
-                            self.next
-                        end 
-                    end
-                    @text << ?]
-                else
-                    raise UnrecognizedType.new typ
-                end
+                raise UnsupportedType.new typ
             end
+
+            return self
         end
         def to_s
             return @text

data/dist/template/bin/runner.rb

@@ -87,6 +87,9 @@ class GettcRunner
         if ret != true
             @errors << n
             @log.debug "Error (cannot execute solver)\n"
+        elsif !File.exists? received
+            @errors << n
+            @log.debug "Error (solver did not produce an output file)\n"
         else
             system "#{@checker} #{expected} #{received}"
             ret = $?.exitstatus

data/dist/template/solve/javascript/Makefile

@@ -0,0 +1,8 @@
+include ../Makefile.common
+
+OUTPUT_D = ../../build/javascript
+SOLVER = ./<%= prob.name %>Solver.js
+
+main: setup
+	@chmod +x $(SOLVER)
+

data/dist/template/solve/javascript/{name}.js

@@ -0,0 +1,7 @@
+<%
+    engine = JavascriptEngine.new func, vars
+%>module.exports = {
+    <%= func.name %> : function(<%= engine.arglist %>) {
+        return <%= func.type.dumb_javascript %>;
+    }
+}

data/dist/template/solve/javascript/{name}Solver.js

@@ -0,0 +1,30 @@
+#! /usr/bin/env node
+<% engine = JavascriptEngine.new func, vars %>
+var fs = require("fs");
+var path = require("path");
+var tc = null;
+
+function init() {
+    var gettcHome = process.env.GETTC_HOME || path.join(process.env.HOME, ".gettc");
+    var includeDir = path.join(gettcHome, "include", "javascript");
+    tc = require(path.join(includeDir, "topcoder"));
+}
+
+function main() { try {
+    var input = fs.readFileSync(process.argv[2], { encoding: "ascii" });
+    var reader = new tc.Reader(input);
+<%= engine.input.gsub(/^/, " " * 4) %>
+
+    var <%= prob.name %> = require("./<%= prob.name %>");
+    var result = <%= prob.name %>.<%= func.name %>(<%= engine.arglist %>);
+    
+    var writer = new tc.Writer();
+    writer.next(result, "<%= func.type.to_s %>");
+    fs.writeFileSync(process.argv[3], writer.toString(), { encoding: "ascii" });
+} catch (err) {
+    console.log(err.toString());
+    console.trace();
+}}
+
+init();
+main();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gettc
 version: !ruby/object:Gem::Version
-  version: '1.9'
+  version: '1.10'
 platform: ruby
 authors:
 - Seri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2015-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hpricot
@@ -76,6 +76,11 @@ files:
 - dist/include/haskell/engine.rb
 - dist/include/java/TopCoder.jar
 - dist/include/java/engine.rb
+- dist/include/javascript/engine.rb
+- dist/include/javascript/topcoder.js
+- dist/include/javascript/topcoder/errors.js
+- dist/include/javascript/topcoder/reader.js
+- dist/include/javascript/topcoder/writer.js
 - dist/include/python/engine.rb
 - dist/include/python/topcoder/__init__.py
 - dist/include/python/topcoder/__init__.pyc
@@ -110,6 +115,9 @@ files:
 - dist/template/solve/java/build.xml
 - dist/template/solve/java/{name}.java
 - dist/template/solve/java/{name}Solver.java
+- dist/template/solve/javascript/Makefile
+- dist/template/solve/javascript/{name}.js
+- dist/template/solve/javascript/{name}Solver.js
 - dist/template/solve/python/Makefile
 - dist/template/solve/python/{name}.py
 - dist/template/solve/python/{name}Solver.py