gettc 1.10 → 2.0

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

@@ -1,46 +1,50 @@
 var tc = require("./errors");
 
 function Writer() {
-    this.text = "";
+  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;
+  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();
+      }
     }
-    throw new tc.UnsupportedType(type);
+
+    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;
+  return this.text;
 };
 
 module.exports = Writer;

data/dist/include/python/engine.rb

@@ -1,65 +1,56 @@
 require "gettc/types"
 
 module Gettc
-    class Type
-        def dumb_python
-            if is_a? TArray then
-                return "[]"
-            end
+  class Type
+    def dumb_python
+      return "[]" if self.is_a?(TArray)
+
+      case self
+      when TInt, TLong, TFloat, TDouble
+        "0"
+      when TChar
+        "'$'"
+      when TString
+        '"$"'
+      when TBoolean
+        "True"
+      else
+        "None"
+      end
+    end
+  end
 
-            case self
-            when TInt, TLong, TFloat, TDouble
-                return "0"
-            when TChar
-                return "'$'"
-            when TString
-                return '"$"'
-            when TBoolean
-                return "True"
-            end
+  class PythonEngine
+    attr_reader :arglist, :input, :shebang
 
-            return "None"
-        end
-    end
-    class PythonEngine
-        attr_reader :arglist, :input, :shebang
-        def initialize func, vars
-            temp = vars.map do |var|
-                var.name
-            end
-            @arglist = temp.join ", "
+    def initialize(func, vars)
+      @arglist = vars.map(&:name).join(", ")
 
-            temp = vars.map do |var| 
-                var.name + ' = reader.next("' + var.type.to_s + '")'
-            end
-            @input = temp.join "\nreader.next()\n"
+      @input = vars.map do |var|
+        "#{var.name} = reader.next(\"#{var.type}\")"
+      end.join("\nreader.next()\n")
+
+      @shebang = "#! #{python3_path}"
+    end
 
-            @shebang = "#! "
-            @shebang << python3_path
-        end
     private
-        def python3_path
-            default = "/usr/bin/env python"
 
-            version = system_q("python --version").split
-            if version.size != 2 || version[0].upcase != "PYTHON" then
-                return default
-            end
+    def python3_path
+      default = "/usr/bin/env python"
 
-            version = version[1].split(".")[0].to_i
-            if version >= 3 then
-                return default
-            end 
+      version = system_q("python --version").split
+      return default if version.size != 2 || version[0].upcase != "PYTHON"
+
+      version = version[1].split(".")[0].to_i
+      return default if version >= 3
+
+      system_q("which python3") || default
+    rescue
+      return default
+    end
 
-            python3 = system_q "which python3"
-            return python3.empty? ? default : python3
-        rescue
-            return default
-        end
-        def system_q command
-            IO.popen command, err: [:child, :out] do |f|
-                return f.gets
-            end
-        end
+    def system_q(command)
+      IO.popen(command, err: [:child, :out]) { |f| f.gets }
     end
+  end
 end

data/dist/include/ruby/engine.rb

@@ -1,62 +1,57 @@
 require "gettc/types"
 
 module Gettc
-    class Type
-        def to_ruby
-            if is_a? TArray
-                return "TArray.new(#{subtype.to_ruby})"
-            end 
+  class Type
+    def to_ruby
+      return "TArray.new(#{subtype.to_ruby})" if self.is_a?(TArray)
 
-            case self
-            when TInt
-                return "TInt"
-            when TLong
-                return "TLong"
-            when TFloat
-                return "TFloat"
-            when TDouble
-                return "TDouble"
-            when TChar
-                return "TChar"
-            when TString
-                return "TString"
-            when TBoolean
-                return "TBoolean"
-            end
-
-            return "Object"
-        end
-        def dumb_ruby
-            if is_a? TArray then
-                return "[]"
-            end
+      case self
+      when TInt
+        "TInt"
+      when TLong
+        "TLong"
+      when TFloat
+        "TFloat"
+      when TDouble
+        "TDouble"
+      when TChar
+        "TChar"
+      when TString
+        "TString"
+      when TBoolean
+        "TBoolean"
+      else
+        "Object"
+      end
+    end
 
-            case self
-            when TInt, TLong, TFloat, TDouble
-                return "0"
-            when TChar
-                return "?$"
-            when TString
-                return '"$"'
-            when TBoolean
-                return "true"
-            end
+    def dumb_ruby
+      return "[]" if self.is_a?(TArray)
 
-            return "nil"
-        end
+      case self
+      when TInt, TLong, TFloat, TDouble
+        "0"
+      when TChar
+        "?$"
+      when TString
+        '"$"'
+      when TBoolean
+        "true"
+      else
+        "nil"
+      end
     end
-    class RubyEngine
-        attr_reader :arglist, :input
-        def initialize func, vars
-            temp = vars.map do |var|
-                var.name
-            end
-            @arglist = temp.join ", "
+  end
+
+  class RubyEngine
+    attr_reader :arglist, :input
+
+    def initialize(func, vars)
+      @arglist = vars.map(&:name).join(", ")
 
-            temp = vars.map do |var| 
-                var.name + " = reader.next(" + var.type.to_ruby + ")"
-            end
-            @input = temp.join "\nreader.next()\n"
-        end
+      @input = vars.map do |var|
+        "#{var.name} = reader.next(#{var.type.to_ruby})"
+      end.join("\nreader.next()\n")
     end
+  end
 end

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

@@ -2,212 +2,224 @@ require "gettc/types"
 include Gettc
 
 module TopCoder
-    class ParseError < StandardError
-        def initialize text, pos, info = ""
-            message = text
-            if pos < text.size && pos >= 0
-                message = pos == 0 ? "" : text[0..(pos - 1)]
-                message << "|"
-                message << text[pos]
-                message << "|"
-                message << text[(pos + 1)..(-1)]
-            end 
-            message = "<#{message}>"
-            if info
-                message += " (" + info + ")"
-            end 
-            super message            
-        end
+  class ParseError < StandardError
+    def initialize(text, pos, info = "")
+      message = text
+
+      if pos < text.size && pos >= 0
+        message = pos == 0 ? "" : text[0..(pos - 1)]
+        message << "|" << text[pos] << "|"
+        message << text[(pos + 1)..(-1)]
+      end
+
+      message = "<#{message}>"
+      message << " (#{info})" if info
+
+      super message
     end
+  end
 
-    class Reader
-        def initialize text
-            if !text.is_a? String
-                raise TypeError.new "need a string to construct a Reader"
-            end 
-            @text = text
-            @pos = 0
-            @len = @text.size
-        end
-        def next typ = nil
-            if typ.nil?
-                spaces
-                expect ?,
-                return                 
-            end 
-
-            case typ
-            when TBoolean
-                return next_boolean
-            when TInt, TLong
-                return next_int
-            when TFloat, TDouble
-                return next_float
-            when TChar
-                return next_char
-            when TString
-                return next_string
-            else 
-                if typ.is_a? TArray
-                    return next_array typ.subtype
-                end
-            end
-
-            raise UnsupportedType.new typ
-        end
+  class Reader
+    def initialize(text)
+      raise ArgumentError.new("need a string to construct a Reader") unless text.is_a?(String)
+      @text = text
+      @pos = 0
+      @len = @text.size
+    end
+
+    def next(type = nil)
+      if type.nil?
+        spaces
+        expect(?,)
+        return
+      end
+
+      return next_array(type.subtype) if type.is_a?(TArray)
+
+      case type
+      when TBoolean
+        next_boolean
+      when TInt, TLong
+        next_int
+      when TFloat, TDouble
+        next_float
+      when TChar
+        next_char
+      when TString
+        next_string
+      else
+        raise UnsupportedType.new(type)
+      end
+    end
 
     private
-        def raise_here message = nil
-            raise ParseError.new @text, @pos, message
-        end
-        def check_pos
-            if @pos >= @len
-                raise_here "unexpected end of input"
-            end             
-        end
 
-        def token
-            check_pos
-            return @text[@pos]
-        end
-        def spaces
-            while @pos < @len && @text[@pos] =~ /\s/ do
-                @pos += 1
-            end
-        end
-        def expect char
-            if token == char
-                @pos += 1
-            else
-                raise_here "expecting <#{char}>"
-            end 
-        end
+    def raise_here(message = nil)
+      raise ParseError.new(@text, @pos, message)
+    end
 
-        def next_boolean
-            spaces
-            if @text[@pos, 4].upcase == "TRUE"
-                @pos += 4
-                return true
-            elsif @text[@pos, 5].upcase == "FALSE"
-                @pos += 5
-                return false
-            end 
-            raise_here "expecting either true or false"
-        end
+    def check_pos
+      raise_here("unexpected end of input") if @pos >= @len
+    end
 
-        def is_digit
-            return @text[@pos] =~ /\d/
-        end
-        def next_digits
-            check_pos
-            if !is_digit
-                raise_here "expecting a digit"                
-            end 
-            start = @pos
-            while true do
-                @pos += 1
-                if @pos == @len || !is_digit
-                    break
-                end 
-            end
-            return @text[start..(@pos - 1)]
-        end
+    def token
+      check_pos
+      @text[@pos]
+    end
 
-        def next_positive_int
-            return next_digits.to_i
-        end
-        def next_int
-            spaces
-            if token == ?-
-                @pos += 1
-                return -next_positive_int
-            end 
-            return next_positive_int
-        end
+    def spaces
+      while @pos < @len && @text[@pos] =~ /\s/ do
+        @pos += 1
+      end
+    end
 
-        def next_positive_float
-            str = next_digits
-            if @pos < @len
-                if @text[@pos] == ?.
-                    @pos += 1
-                    str << "." << next_digits
-                end 
-            end 
-            return str.to_f
-        end
-        def next_float
-            spaces
-            if token == ?-
-                @pos += 1
-                return -next_positive_float
-            end 
-            return next_positive_float
-        end
+    def expect(char)
+      if token == char
+        @pos += 1
+      else
+        raise_here("expecting <#{char}>")
+      end
+    end
 
-        def next_char
-            spaces
-            char = token
-            if char == ?'
-                @pos += 1
-                ret = token
-                @pos += 1
-                expect ?'
-                return ret
-            end 
-            @pos += 1
-            return char
-        end
+    def next_boolean
+      spaces
 
-        def next_string
-            spaces
-            expect ?"
-            start = @pos
-            while true do
-                if @pos >= @len
-                    raise_here "expecting a closing quote when reading a string"
-                end 
-                if token == ?"
-                    @pos += 1
-                    saved = @pos
-                    spaces
-                    if @pos == @len || @text[@pos] == ?, || @text[@pos] == ?]
-                        @pos = saved
-                        return @text[start..(@pos - 2)]
-                    end 
-                else
-                    @pos += 1
-                end 
-            end
-        end
+      if @text[@pos, 4].upcase == "TRUE"
+        @pos += 4
+        return true
+      elsif @text[@pos, 5].upcase == "FALSE"
+        @pos += 5
+        return false
+      end
 
-        def next_elems elem_type, arr
-            spaces
-            char = token
-            case char
-            when ?]
-                @pos += 1
-                return
-            when ?,
-                @pos += 1
-                arr << self.next(elem_type)
-                next_elems elem_type, arr
-            else
-                raise_here "expecting either <,> or <]>"
-            end
-        end
+      raise_here("expecting either true or false")
+    end
 
-        def next_array elem_type
-            arr = []
-            spaces
-            expect ?[
-            spaces
-            if token == ?]
-                @pos += 1
-                return arr
-            end 
-            arr << self.next(elem_type)
-            next_elems elem_type, arr
-            return arr
+    def is_digit
+      @text[@pos] =~ /\d/
+    end
+
+    def next_digits
+      check_pos
+      raise_here("expecting a digit") unless is_digit
+
+      start = @pos
+      while true do
+        @pos += 1
+        break if @pos == @len || !is_digit
+      end
+
+      @text[start..(@pos - 1)]
+    end
+
+    def next_positive_int
+      next_digits.to_i
+    end
+
+    def next_int
+      spaces
+
+      if token == ?-
+        @pos += 1
+        return -next_positive_int
+      end
+
+      next_positive_int
+    end
+
+    def next_positive_float
+      str = next_digits
+
+      if @pos < @len
+        if @text[@pos] == ?.
+          @pos += 1
+          str << "." << next_digits
         end
+      end
+
+      str.to_f
+    end
+
+    def next_float
+      spaces
+
+      if token == ?-
+        @pos += 1
+        return -next_positive_float
+      end
+
+      return next_positive_float
+    end
+
+    def next_char
+      spaces
+      char = token
+
+      if char == ?'
+        @pos += 1
+        ret = token
+        @pos += 1
+        expect(?')
+        return ret
+      end
+
+      @pos += 1
+      char
+    end
+
+    def next_string
+      spaces
+      expect(?")
+      start = @pos
+      while true do
+        raise_here("expecting a closing quote when reading a string") if @pos >= @len
+        if token == ?"
+          @pos += 1
+          saved = @pos
+          spaces
+          if @pos == @len || @text[@pos] == ?, || @text[@pos] == ?]
+            @pos = saved
+            return @text[start..(@pos - 2)]
+          end
+        else
+          @pos += 1
+        end
+      end
+    end
+
+    def next_elems(elem_type, arr)
+      spaces
+      char = token
+
+      case char
+      when ?]
+        @pos += 1
+        return
+      when ?,
+        @pos += 1
+        arr << self.next(elem_type)
+        next_elems(elem_type, arr)
+      else
+        raise_here("expecting either <,> or <]>")
+      end
+    end
+
+    def next_array(elem_type)
+      arr = []
+
+      spaces
+      expect(?[)
+      spaces
+
+      if token == ?]
+        @pos += 1
+        return arr
+      end
+
+      arr << self.next(elem_type)
+      next_elems(elem_type, arr)
+
+      arr
     end
+  end
 end