Fix command line

Author: alehander92

bin/pseudo-python

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+
+public class Result
+{
+    private readonly string host;
+    public string Host { get { return host; } }
+
+    private readonly string away;
+    public string Away { get { return away; } }
+
+    private readonly int[] goals;
+    public int[] Goals { get { return goals; } }
+
+    public Result(string host, string away, int[] goals)
+    {
+        this.host = host;
+        this.away = away;
+        this.goals = goals;
+    }
+}
+
+public class Program
+{
+    static List<Result> LoadResults(string filename)
+    {
+        var raw = File.ReadAllText(filename);
+        var lines = raw.Split('\n');
+        return lines
+            .Where(line => line.Length != 0)
+            .Select(line => ParseResult(line))
+            .ToList();
+    }
+
+    static Result ParseResult(string line)
+    {
+        var awayIndex = line.IndexOf(" - ") + 3;
+        var resultIndex = line.IndexOf(" ", awayIndex) + 1;
+        var goals = line.Substring(resultIndex).Split(':');
+        return new Result(line.Substring(0, awayIndex - 3), line.Substring(awayIndex, resultIndex - 1 - awayIndex), new[] { Int32.Parse(goals[0]), Int32.Parse(goals[1]) });
+    }
+
+    static int CalculatePoints(List<Result> results, string team)
+    {
+        return results.Aggregate(0, (memo, result) => memo + ResultPoints(team, result));
+    }
+
+    static int ResultPoints(string team, Result result)
+    {
+        if (result.Host == team && result.Goals[0] > result.Goals[1] || result.Away == team && result.Goals[0] < result.Goals[1])
+        {
+            return 3;
+        }
+        else if (result.Goals[0] == result.Goals[1] && (result.Host == team || result.Away == team))
+        {
+            return 1;
+        }
+        else 
+        {
+            return 0;
+        }
+    }
+
+    public static void Main(string[] args)
+    {
+        if (args.Length < 2)
+        {
+            Console.WriteLine("usage: football <stats-file> <team>");
+        }
+        else 
+        {
+            var results = LoadResults(args[0]);
+            Console.WriteLine(CalculatePoints(results, args[1]));
+        }
+    }
+}

examples/football.cs

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"strings"
+	"strconv"
+	"fmt"
+	"io/ioutil"
+	"os"
+)
+
+func LoadResults(filename string) []Result {
+	_contents, _ := ioutil.ReadFile(filename)
+	raw := string(_contents)
+	lines := strings.Split(raw, "\n")
+	var _results []Result
+	for _, line := range lines {
+		if len(line) > 0 {
+			_results = append(_results, ParseResult(line))
+		}
+	}
+	return _results
+
+}
+
+func ParseResult(line string) *Result {
+	awayIndex := strings.Index(line, " - ") + 3
+	resultIndex := awayIndex + strings.Index(line[awayIndex:], " ") + 1
+	goals := strings.Split(line[resultIndex:], ":")
+	_int, _ := strconv.Atoi(goals[0])
+	_int1, _ := strconv.Atoi(goals[1])
+	return Result{line[:awayIndex - 3], line[awayIndex:resultIndex - 1], [...]int{_int, _int1}}
+}
+
+func CalculatePoints(results []Result, team string) int {
+	accumulator := 0
+	for _, result := range results {
+		accumulator += ResultPoints(team, result)
+	}
+
+	return accumulator
+}
+
+func ResultPoints(team string, result Result) int {
+	if result.Host == team && result.Goals[0] > result.Goals[1] || result.Away == team && result.Goals[0] < result.Goals[1] {
+		return 3
+	} else if result.Goals[0] == result.Goals[1] && (result.Host == team || result.Away == team) {
+		return 1
+	} else {
+		return 0
+	}
+}
+
+type Result struct {
+	Host string
+	Away string
+	Goals [2]int
+}
+
+func main() {
+	if len(os.Args) < 3 {
+		fmt.Println("usage: football <stats-file> <team>")
+	} else {
+		results := LoadResults(os.Args[1])
+		fmt.Println(CalculatePoints(results, os.Args[2]))
+	}
+}

examples/football.go

@@ -0,0 +1,42 @@
+var _ = require('lodash');
+var fs = require('fs');
+function load_results(filename) {
+  var raw = fs.readFileSync(filename, 'utf8');
+  var lines = raw.split('\n');
+  return _.filter(lines, function (line) {
+    return line;
+  }).map(function (line) {
+    return parse_result(line);
+  });
+}
+
+function parse_result(line) {
+  var away_index = line.search(' - ') + 3;
+  var result_index = away_index + line.slice(away_index).search(' ') + 1;
+  var goals = line.slice(result_index).split(':');
+  return [line.slice(0, away_index - 3), line.slice(away_index, result_index - 1), [parseInt(goals[0]), parseInt(goals[1])]];
+}
+
+function calculate_points(results, team) {
+  return _.reduce(results, function (memo, result) {
+    return memo + result_points(team, result[0], result[1], result[2]);
+  }, 0);
+}
+
+function result_points(team, host, away, goals) {
+  if (host == team && goals[0] > goals[1] || away == team && goals[0] < goals[1]) {
+    return 3;
+  } else if (goals[0] == goals[1] && (host == team || away == team)) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+if (process.argv.length < 4) {
+  console.log('usage: football <stats-file> <team>');
+} else {
+  var results = load_results(process.argv[2]);
+  console.log(calculate_points(results, process.argv[3]));
+}
+

examples/football.js

@@ -29,4 +29,4 @@ def result_points(team, host, away, goals):
 else:
     results = load_results(sys.argv[1])
     # print(result_points(sys.argv[2], *results[0]))
-    print(calculate_points(results, sys.argv[2]))
+    print(calculate_points(results, sys.argv[2]))

examples/football.py

@@ -0,0 +1,35 @@
+def load_results(filename)
+  raw = File.read(filename)
+  lines = raw.split("\n")
+  lines.select { |line| !line.empty? }.map { |line| parse_result(line) }
+end
+
+def parse_result(line)
+  away_index = line.index(' - ') + 3
+  result_index = line.index(' ', away_index) + 1
+  goals = line[result_index..-1].split(':')
+  [line[0...away_index - 3], line[away_index...result_index - 1], [goals[0].to_i, goals[1].to_i]]
+end
+
+def calculate_points(results, team)
+  results.reduce(0) { |memo, result| memo + result_points(team, result[0], result[1], result[2]) }
+end
+
+def result_points(team, host, away, goals)
+  if host == team && goals[0] > goals[1] || away == team && goals[0] < goals[1]
+    3
+  elsif goals[0] == goals[1] && (host == team || away == team)
+    1
+  else
+    0
+  end
+
+end
+
+if ARGV.length < 2
+  puts 'usage: football <stats-file> <team>'
+else
+  results = load_results(ARGV[0])
+  puts calculate_points(results, ARGV[1])
+end
+

examples/football.rb

@@ -2,4 +2,4 @@
 import pseudo_python.ast_translator
 
 def translate(source):
-    return pseudo_python.ast_translator.ASTTranslator(pseudo_python.parser.parse(source), source).translate()
+	return pseudo_python.ast_translator.ASTTranslator(pseudo_python.parser.parse(source), source).translate()

pseudo_python/__init__.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+import sys
+import pseudo_python
+import pseudo_python.errors
+import yaml
+import pseudo
+import pseudo.errors
+from colorama import init
+from termcolor import colored
+
+USAGE = '''
+pseudo-python <input-filename.py> [<output-filename> / <language>]
+
+where if you omit <language>, pseudo-python will generate a 
+<input-filename.pseudo.yaml> file with serialized ast 
+
+if <output-filename> is provided, <language> will be extracted from 
+the extension
+
+it can be:
+  py / python 
+  rb / ruby
+  js / javascript
+  cs / csharp
+  go
+
+examples:
+pseudo-python a.py # generates a.pseudo.yaml
+pseudo-python z.py o.rb # generates a ruby translation in o.rb
+'''
+
+def main():
+    if len(sys.argv) == 1:
+        print(USAGE)
+        return
+
+    filename = sys.argv[1]
+    with open(filename, 'r') as f:
+        source = f.read()
+    base = filename.partition('.')[0]
+    try:
+        if len(sys.argv) == 2:
+            yaml.Dumper.ignore_aliases = lambda *args : True
+            clj = yaml.dump(pseudo_python.translate(source))
+            with open('%s.pseudo.yaml' % base, 'w') as f:
+                f.write(clj)
+            print(colored('OK\nsaved pseudo ast as %s.pseudo.yaml' % base, 'green'))
+        else:
+            arg = sys.argv[2]
+            if '.' in arg:
+                base, _, language = arg.rpartition('.')
+            else:
+                language = arg
+            if language not in pseudo.SUPPORTED_FORMATS:
+                print(colored('%s is not supported' % language, 'red'))
+                exit(1)
+            if '%s.%s' % (base, pseudo.FILE_EXTENSIONS[language]) == filename:
+                print(colored('this would overwrite the input file, please choose another name', 'red'))                
+                exit(1)
+            node = pseudo_python.translate(source)
+            output = pseudo.generate(node, language)
+            with open('%s.%s' % (base, pseudo.FILE_EXTENSIONS[language]), 'w') as f:
+                f.write(output)     
+            print(colored('OK\nsaved as %s.%s' % (base, pseudo.FILE_EXTENSIONS[language]), 'green'))
+    except pseudo_python.errors.PseudoError as e:
+        print(colored(e, 'red'))
+        if e.suggestions:
+            print(colored(e.suggestions, 'green'))
+        if e.right:
+            print(colored('\nright:\n%s' % e.right, 'green'))
+        if e.wrong:
+            print(colored('\nwrong:\n%s' % e.wrong, 'red'))
+    except pseudo.errors.PseudoError as e:
+        print(colored('Pseudo error:\n%s' % e, 'red'))
+
+if __name__ == '__main__':
+    main()

pseudo_python/main.py

@@ -1,3 +1,4 @@
 PyYAML==3.11
 colorama
 termcolor
+pseudo>=0.2.3

pseudo_python/tests/assign.py

@@ -0,0 +1,2 @@
+[metadata]
+description-file = README.md