Sentences start with capital letters

Author: alehander92

README.md

@@ -7,7 +7,7 @@ A Python to JavaScript / Ruby / C++ / Go / C# / PHP translator
 
 [Pseudo](https://github.com/alehander42/pseudo) is a framework for high level code generation: it is used by this compiler to translate a subset of Python to all Pseudo-supported languages
 
-## supported subset
+## Supported subset
 
 Pseudo supports a very clear and somehow limited subset of a language:
 
@@ -42,28 +42,28 @@ Pseudo supports a very clear and somehow limited subset of a language:
 pseudo-python checks if your program is using a valid pseudo-translatable subset of Python, type checks it according to pseudo type rules and generates a `<filename>.pseudo.yaml` output file containing pseudo-ast code
 
 [TODO]
-you can directly run `pseudo-python <filename.py> <lang>` e.g.
+You can directly run `pseudo-python <filename.py> <lang>` e.g.
 
 ```bash
 pseudo-python <filename.py> ruby
 pseudo-python <filename.py> cpp
 ``` 
 etc for all the supported pseudo languages (javascript, c++, c#, go, ruby and python)
 
-## error messages
+## Error messages
 
-a lot of work has been put into making pseudo-python error messages as clear and helpful as possible: they show the offending snippet of code and 
+A lot of work has been put into making pseudo-python error messages as clear and helpful as possible: they show the offending snippet of code and 
 often they offer suggestions, list possible fixes or right/wrong ways to write something
 
 ![Screenshot of error messages](http://i.imgur.com/8W7QNgZ.png)
 
-## type inference
+## Type inference
 
-the rules are relatively simple: currently pseudo-python infers everything
+The rules are relatively simple: currently pseudo-python infers everything
 from the usage of functions/classes, so you need to call/initialize all
 of your functions/classes (except for no-arg functions)
 
-often you don't really need to do that for **all** of them, you just need
+Often you don't really need to do that for **all** of them, you just need
 to do it in a way that can create call graphs covering all of them 
 (e.g. often you'll have `a` calling `b` calling `x` and you only need to 
 have an `a` invocation in your source)
@@ -92,13 +92,13 @@ Other pseudo-tips:
 
 * Homogeneous tuples are converted to `pseudo` fixed length arrays and heterogeneous to `pseudo` tuples. in the future `pseudo-python` would analyze better `lists`/`tuple` usage to classify them better in `list`/`array`/`tuple` categories (which can optimize the resulting code in `go`/`c++`/`c#`)
 
-* attributes that aren't called from other classes are translated as `private`, the other ones as `public`. The rule for methods is different:
+* Attributes that aren't called from other classes are translated as `private`, the other ones as `public`. The rule for methods is different:
 `_name` ones are only translated as `private`. That can be added as
 config option in the future
 
-* multiple returns values are supported, but they are converted to `array`/`tuple`
+* Multiple returns values are supported, but they are converted to `array`/`tuple`
 
-* single inheritance is supported, `pseudo-python` supports polymorphism
+* Single inheritance is supported, `pseudo-python` supports polymorphism
 but methods in children should accept the same types as their equivalents in the hierarchy (except `__init__`)
 
 The easiest way to play with the type system is to just try several programs: `pseudo-python` errors should be enough to guide you, if not, 

example/f.py

@@ -1,4 +1,7 @@
-class ExError(Exception):
-    pass
+class L:
+	def __init__(self, a):
+		self.a = a
 
-raise ExError("s")
+s = L(2)
+e = 'x'
+e.k()

tests/test_python.py

@@ -76,6 +76,7 @@ def translate(self, source):
         #         'pseudo_type': 'Void'
         #     }]
         # },
+        # extensive tests in v0.3/v0.4 when ast spec stabilizes
         function = {
             t('''
             def x(a):