Merge pull request RustPython#533 from RustPython/master

Update the demo page and docs website.

Author: windelbouwman

.gitignore

@@ -5,4 +5,6 @@ __pycache__
 **/*.pytest_cache
 .*sw*
 .repl_history.txt
+.vscode
 wasm-pack.log
+.idea/

.travis.yml

@@ -16,6 +16,7 @@ env:
 cache: cargo
 
 matrix:
+  fast_finish: true
   include:
     # To test the snippets, we use Travis' Python environment (because
     # installing rust ourselves is a lot easier than installing Python)
@@ -31,6 +32,7 @@ matrix:
       env:
         - TRAVIS_RUST_VERSION=stable
         - REGULAR_TEST=false
+        - CODE_COVERAGE=false
       script: tests/.travis-runner.sh
     - language: python
       python: 3.6
@@ -44,6 +46,7 @@ matrix:
       env:
         - TRAVIS_RUST_VERSION=beta
         - REGULAR_TEST=false
+        - CODE_COVERAGE=false
       script: tests/.travis-runner.sh
     - name: rustfmt
       language: rust
@@ -86,9 +89,36 @@ matrix:
       env:
         - REGULAR_TEST=false
         - DEPLOY_DEMO=true
+    - name: cargo-clippy
+      language: rust
+      rust: stable
+      cache: cargo
+      before_script:
+        - rustup component add clippy
+      script:
+        - cargo clippy
+      env:
+        - REGULAR_TEST=true
+    - name: Code Coverage
+      language: python
+      python: 3.6
+      cache:
+        pip: true
+        # Because we're using the Python Travis environment, we can't use
+        # the built-in cargo cacher
+        directories:
+          - /home/travis/.cargo
+          - target
+      script:
+        - tests/.travis-runner.sh
+      env:
+        - TRAVIS_RUST_VERSION=nightly
+        - REGULAR_TEST=false
+        - CODE_COVERAGE=true
   allow_failures:
     - rust: nightly
       env: REGULAR_TEST=true
+    - name: cargo-clippy
 
 deploy:
   - provider: pages

Cargo.lock

@@ -2,6 +2,7 @@
 name = "rustpython"
 version = "0.0.1"
 authors = ["Windel Bouwman", "Shing Lyu <[email protected]>"]
+edition = "2018"
 
 [workspace]
 members = [".", "vm", "wasm/lib", "parser"]
@@ -13,6 +14,7 @@ clap = "2.31.2"
 rustpython_parser = {path = "parser"}
 rustpython_vm = {path = "vm"}
 rustyline = "2.1.0"
+xdg = "2.2.0"
 
 [profile.release]
 opt-level = "s"

Cargo.toml

@@ -3,6 +3,8 @@
 A Python-3 (CPython >= 3.5.0) Interpreter written in Rust :snake: :scream: :metal:.
 
 [![Build Status](https://travis-ci.org/RustPython/RustPython.svg?branch=master)](https://travis-ci.org/RustPython/RustPython)
+[![Build Status](https://dev.azure.com/ryan0463/ryan/_apis/build/status/RustPython.RustPython?branchName=master)](https://dev.azure.com/ryan0463/ryan/_build/latest?definitionId=1&branchName=master)
+[![codecov](https://codecov.io/gh/RustPython/RustPython/branch/master/graph/badge.svg)](https://codecov.io/gh/RustPython/RustPython)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Contributors](https://img.shields.io/github/contributors/RustPython/RustPython.svg)](https://github.com/RustPython/RustPython/graphs/contributors)
 [![Gitter](https://badges.gitter.im/RustPython/Lobby.svg)](https://gitter.im/rustpython/Lobby)
@@ -25,14 +27,22 @@ Or use the interactive shell:
     >>>>> 2+2
     4
 
+# Disclaimer
+
+  RustPython is in a development phase and should not be used in production or a fault intolerant setting.
+
+  Our current build supports only a subset of Python syntax.
+
+  Contribution is also more than welcome! See our contribution section for more information on this. 
+
 # Goals
 
 - Full Python-3 environment entirely in Rust (not CPython bindings)
 - A clean implementation without compatibility hacks
 
 # Documentation
 
-Currently the project is in an early phase, and so is the documentation.
+Currently along with other areas of the project, documentation is still in an early phase.
 
 You can read the [online documentation](https://rustpython.github.io/website/rustpython/index.html) for the latest code on master.
 
@@ -45,7 +55,7 @@ $ cargo doc --no-deps --all # Excluding all dependencies
 
 Documentation HTML files can then be found in the `target/doc` directory.
 
-If you wish to update the online documentation. Push directly to the `release` branch (or ask a maintainer to do so), this will trigger a Travis build that updates the documentation and WebAssembly demo page.
+If you wish to update the online documentation, push directly to the `release` branch (or ask a maintainer to do so). This will trigger a Travis build that updates the documentation and WebAssembly demo page.
 
 # Code organization
 
@@ -56,18 +66,20 @@ If you wish to update the online documentation. Push directly to the `release` b
   - `obj`: python builtin types
 - `src`: using the other subcrates to bring rustpython to life.
 - `docs`: documentation (work in progress)
-- `py_code_object`: CPython bytecode to rustpython bytecode convertor (work in progress)
+- `py_code_object`: CPython bytecode to rustpython bytecode converter (work in progress)
 - `wasm`: Binary crate and resources for WebAssembly build
 - `tests`: integration test snippets
 
 # Contributing
 
-To start contributing, there are a lot of things that need to be done.
+Contributions are more than welcome, and in many cases we are happy to guide contributors through PRs or on gitter.
+
+With that in mind, please note this project is maintained by volunteers, some of the best ways to get started are below:
 
 Most tasks are listed in the [issue tracker](https://github.com/RustPython/RustPython/issues).
 Check issues labeled with `good first issue` if you wish to start coding.
 
-Another approach is to checkout the sourcecode: builtin functions and object methods are often the simplest
+Another approach is to checkout the source code: builtin functions and object methods are often the simplest
 and easiest way to contribute.
 
 You can also simply run
@@ -81,11 +93,11 @@ To test rustpython, there is a collection of python snippets located in the
 
 ```shell
 $ cd tests
-$ pipenv shell
-$ pytest -v
+$ pipenv install
+$ pipenv run pytest -v
 ```
 
-There also are some unittests, you can run those will cargo:
+There also are some unit tests, you can run those will cargo:
 
 ```shell
 $ cargo test --all

README.md

@@ -0,0 +1,56 @@
+trigger:
+- master
+
+jobs:
+
+- job: 'Test'
+  pool:
+    vmImage: 'vs2017-win2016'
+  strategy:
+    matrix:
+      Python37:
+        python.version: '3.7'
+    maxParallel: 10
+
+  steps:
+  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '$(python.version)'
+      architecture: 'x64'
+
+  - script: |
+      "C:\Program Files\Git\mingw64\bin\curl.exe" -sSf -o rustup-init.exe https://win.rustup.rs/
+      .\rustup-init.exe -y
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustc -V
+      cargo -V
+    displayName: 'Installing Rust'
+
+  - script: |
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      cargo build --verbose --all
+    displayName: 'Build'
+
+  - script: |
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      cargo test --verbose --all
+    displayName: 'Run tests'
+
+  - script: |
+      pip install pipenv
+      pushd tests
+      pipenv install
+      popd
+    displayName: 'Install pipenv and python packages'
+
+  - script: |
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      cargo build --verbose --release
+    displayName: 'Build release'
+
+  - script: |
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      pushd tests
+      pipenv run pytest
+      popd
+    displayName: 'Run snippet tests'

azure-pipelines.yml

@@ -1,6 +1,6 @@
 Byterun
 
-* Builtins are exposted to frame.f_builtins
+* Builtins are exposed to frame.f_builtins
 * f_builtins is assigned during frame creation,
     self.f_builtins = f_locals['__builtins__']
     if hasattr(self.f_builtins, '__dict__'):
@@ -21,10 +21,10 @@ TODO:
 * Implement a new type NativeFunction
 * Wrap a function pointer in NativeFunction
 * Refactor the CALL_FUNCTION case so it can call both python function and native function
-* During frame creation, force push a nativefunction `print` into the namespace
+* During frame creation, force push a native function `print` into the namespace
 * Modify LOAD_* so they can search for names in builtins
 
 * Create a module type
 * In VM initialization, load the builtins module into locals
-* During frame creation, create a field that conatins the builtins dict
+* During frame creation, create a field that contains the builtins dict
 

docs/builtins.md

@@ -3,6 +3,7 @@ name = "rustpython_parser"
 version = "0.0.1"
 authors = [ "Shing Lyu", "Windel Bouwman" ]
 build = "build.rs"
+edition = "2018"
 
 [build-dependencies]
 lalrpop="0.15.1"

parser/Cargo.toml

@@ -1,4 +1,4 @@
-extern crate lalrpop;
+use lalrpop;
 
 fn main() {
     lalrpop::process_root().unwrap();

parser/build.rs

@@ -65,9 +65,9 @@ pub enum Statement {
         value: Expression,
     },
     AugAssign {
-        target: Expression,
+        target: Box<Expression>,
         op: Operator,
-        value: Expression,
+        value: Box<Expression>,
     },
     Expression {
         expression: Expression,
@@ -197,7 +197,7 @@ pub enum Expression {
         elements: Vec<Expression>,
     },
     String {
-        value: String,
+        value: StringGroup,
     },
     Bytes {
         value: Vec<u8>,
@@ -219,9 +219,53 @@ pub enum Expression {
     None,
 }
 
+impl Expression {
+    /// Returns a short name for the node suitable for use in error messages.
+    pub fn name(&self) -> &'static str {
+        use self::Expression::*;
+        use self::StringGroup::*;
+
+        match self {
+            BoolOp { .. } | Binop { .. } | Unop { .. } => "operator",
+            Subscript { .. } => "subscript",
+            Yield { .. } | YieldFrom { .. } => "yield expression",
+            Compare { .. } => "comparison",
+            Attribute { .. } => "attribute",
+            Call { .. } => "function call",
+            Number { .. }
+            | String {
+                value: Constant { .. },
+            }
+            | Bytes { .. } => "literal",
+            List { .. } => "list",
+            Tuple { .. } => "tuple",
+            Dict { .. } => "dict display",
+            Set { .. } => "set display",
+            Comprehension { kind, .. } => match **kind {
+                ComprehensionKind::List { .. } => "list comprehension",
+                ComprehensionKind::Dict { .. } => "dict comprehension",
+                ComprehensionKind::Set { .. } => "set comprehension",
+                ComprehensionKind::GeneratorExpression { .. } => "generator expression",
+            },
+            Starred { .. } => "starred",
+            Slice { .. } => "slice",
+            String {
+                value: Joined { .. },
+            }
+            | String {
+                value: FormattedValue { .. },
+            } => "f-string expression",
+            Identifier { .. } => "named expression",
+            Lambda { .. } => "lambda",
+            IfExpression { .. } => "conditional expression",
+            True | False | None => "keyword",
+        }
+    }
+}
+
 /*
  * In cpython this is called arguments, but we choose parameters to
- * distuingish between function parameters and actual call arguments.
+ * distinguish between function parameters and actual call arguments.
  */
 #[derive(Debug, PartialEq, Default)]
 pub struct Parameters {
@@ -312,3 +356,17 @@ pub enum Number {
     Float { value: f64 },
     Complex { real: f64, imag: f64 },
 }
+
+#[derive(Debug, PartialEq)]
+pub enum StringGroup {
+    Constant {
+        value: String,
+    },
+    FormattedValue {
+        value: Box<Expression>,
+        spec: String,
+    },
+    Joined {
+        values: Vec<StringGroup>,
+    },
+}