├── .editorconfig
├── .eslintrc.js
├── .github
    └── ISSUE_TEMPLATE
    │   └── bug_report.md
├── .gitignore
├── .nycrc
├── .travis.yml
├── .vscode
    ├── bookmarks.json
    ├── launch.json
    └── settings.json
├── .vscodeignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE.md
├── README.md
├── dist
    ├── assets
    │   ├── 128.png
    │   ├── 512.png
    │   └── logo.png
    └── theme
    │   ├── dark-plus-syntax-color-theme.json
    │   ├── dark-plus-syntax-high-contrast-color-theme.json
    │   ├── light-plus-syntax-color-theme.json
    │   ├── light-plus-syntax-high-contrast-color-theme.json
    │   └── monaco.dark-plus-syntax-color-theme.json
├── package-lock.json
├── package.json
├── src
    ├── index.ts
    ├── lib
    │   ├── build-rules.ts
    │   ├── build-theme.ts
    │   ├── build-ui-colors.ts
    │   ├── config.ts
    │   ├── index.ts
    │   └── write-file.ts
    ├── main.ts
    ├── palettes
    │   ├── DarkPlusHighContrastPalette.ts
    │   ├── DarkPlusPalette.ts
    │   ├── LightPlusHighContrastPalette.ts
    │   ├── LightPlusPalette.ts
    │   ├── index.ts
    │   └── scratch
    │   │   ├── GruvboxPlusPalette.ts
    │   │   └── gruvbox.vim
    ├── theme
    │   ├── index.ts
    │   ├── shared
    │   │   ├── defaults.ts
    │   │   ├── index.ts
    │   │   ├── languages
    │   │   │   ├── c.ts
    │   │   │   ├── cfml.ts
    │   │   │   ├── cpp.ts
    │   │   │   ├── crystal.ts
    │   │   │   ├── cs.ts
    │   │   │   ├── csv.ts
    │   │   │   ├── dart.ts
    │   │   │   ├── dictionary.ts
    │   │   │   ├── elixir.ts
    │   │   │   ├── elm.ts
    │   │   │   ├── erlang.ts
    │   │   │   ├── git.ts
    │   │   │   ├── go.ts
    │   │   │   ├── google-sheets.ts
    │   │   │   ├── graphql.ts
    │   │   │   ├── haskell.ts
    │   │   │   ├── html
    │   │   │   │   ├── html.ts
    │   │   │   │   └── index.ts
    │   │   │   ├── index.ts
    │   │   │   ├── ini.ts
    │   │   │   ├── java
    │   │   │   │   ├── groovy.ts
    │   │   │   │   ├── index.ts
    │   │   │   │   ├── java.ts
    │   │   │   │   ├── kotlin.ts
    │   │   │   │   └── scala.ts
    │   │   │   ├── javascript.ts
    │   │   │   ├── json.ts
    │   │   │   ├── lisp.ts
    │   │   │   ├── makefile.ts
    │   │   │   ├── markdown.ts
    │   │   │   ├── nginx.ts
    │   │   │   ├── org-mode.ts
    │   │   │   ├── protobuf.ts
    │   │   │   ├── python.ts
    │   │   │   ├── regexp.ts
    │   │   │   ├── ruby.ts
    │   │   │   ├── rust.ts
    │   │   │   ├── smarty.ts
    │   │   │   ├── styles
    │   │   │   │   ├── css.ts
    │   │   │   │   ├── index.ts
    │   │   │   │   ├── styled-components.ts
    │   │   │   │   └── stylus.ts
    │   │   │   ├── swift.ts
    │   │   │   ├── terraform.ts
    │   │   │   ├── todo-txt.ts
    │   │   │   ├── toml.ts
    │   │   │   ├── vcard.ts
    │   │   │   ├── viml.ts
    │   │   │   └── yaml.ts
    │   │   ├── semanticTokenColors.ts
    │   │   └── ui.ts
    │   └── ui
    │   │   ├── dark-high-contrast-ui.ts
    │   │   ├── dark-ui.ts
    │   │   ├── index.ts
    │   │   ├── light-high-contrast-ui.ts
    │   │   └── light-ui.ts
    ├── themes
    │   ├── DarkPlus.ts
    │   ├── DarkPlusHighContrast.ts
    │   ├── LightPlus.ts
    │   ├── LightPlusHighContrast.ts
    │   └── index.ts
    └── types
    │   ├── ColorMap.ts
    │   ├── FontStyleString.ts
    │   ├── HexColorString.ts
    │   ├── TextMateRule.ts
    │   ├── ThemeType.ts
    │   ├── TokenScopes.ts
    │   ├── TokenStyleData.ts
    │   ├── VisualStudioCodeTheme.ts
    │   ├── VisualStudioCodeThemeColors.ts
    │   ├── custom
    │       ├── TextMateRuleData.ts
    │       ├── ThemeColor.ts
    │       ├── ThemeColorPalette.ts
    │       ├── ThemeSettings.ts
    │       └── index.ts
    │   └── index.ts
├── test
    ├── samples
    │   ├── .vscode
    │   │   └── settings.json
    │   ├── CS
    │   │   ├── AnswerQue.cs
    │   │   ├── Dapper.CommandDefinition.cs
    │   │   ├── Dapper.SQLMapperExtension.cs
    │   │   ├── TrueFalse.cs
    │   │   ├── sample1.cs
    │   │   ├── sample2.cs
    │   │   └── sample3.cs
    │   ├── Dockerfiles
    │   │   ├── .dockerignore
    │   │   ├── 1.Dockerfile
    │   │   ├── 2.Dockerfile
    │   │   ├── Dockerfile
    │   │   └── go.Dockerfile
    │   ├── JS
    │   │   ├── .eslintrc.js
    │   │   ├── GHpages.vue.html
    │   │   ├── MyElement.js
    │   │   ├── TS
    │   │   │   ├── array.ts
    │   │   │   ├── build-toc.ts
    │   │   │   ├── calculator.ts
    │   │   │   ├── case.ts
    │   │   │   ├── cyph.demo.ts
    │   │   │   ├── cyph.helper.ts
    │   │   │   ├── editable-article-resolver.service.ts
    │   │   │   ├── gov.parse.ts
    │   │   │   ├── home.component.ts
    │   │   │   ├── login-page.component.ts
    │   │   │   └── server.ts
    │   │   ├── as.js
    │   │   ├── case.js
    │   │   ├── decorators
    │   │   │   ├── HelloWorld.vue
    │   │   │   ├── SObject.js
    │   │   │   ├── SObject.ts
    │   │   │   ├── app.module.js
    │   │   │   ├── app.module.ts
    │   │   │   └── decorators.ts
    │   │   ├── destruct.js
    │   │   ├── gulpfile.js
    │   │   ├── imports.js
    │   │   ├── jsx
    │   │   │   ├── BurgerBuilder.jsx
    │   │   │   ├── Clock.jsx
    │   │   │   ├── StyledComponents.jsx
    │   │   │   ├── folder.js
    │   │   │   ├── folder.jsx
    │   │   │   ├── render-props.jsx
    │   │   │   └── touchy-tags
    │   │   │   │   ├── 01.js
    │   │   │   │   ├── Toggle.js
    │   │   │   │   └── bind.js
    │   │   ├── regex.js
    │   │   ├── sample.coffee
    │   │   ├── sample.js
    │   │   ├── tsx
    │   │   │   └── About.tsx
    │   │   └── webpack.config.js
    │   ├── Make
    │   │   ├── CMakelists.txt
    │   │   ├── Makefile
    │   │   └── gcc.mak
    │   ├── Misc
    │   │   ├── LearnHaxe3.hx
    │   │   ├── LearnPowershell.ps1
    │   │   ├── etc
    │   │   │   ├── .gitignore
    │   │   │   ├── Gopkg.lock
    │   │   │   ├── config
    │   │   │   ├── default.conf
    │   │   │   ├── example.sln
    │   │   │   ├── nginx.conf
    │   │   │   ├── package.json
    │   │   │   └── todo.txt
    │   │   ├── learn-latex.tex
    │   │   ├── learnawk.awk
    │   │   ├── learndart.dart
    │   │   ├── learnfortran.f95
    │   │   ├── learnfsharp.fs
    │   │   ├── learnhack.php
    │   │   ├── learnjulia.jl
    │   │   ├── learnocaml.ml
    │   │   ├── learnperl.pl
    │   │   ├── learnperl6.p6
    │   │   ├── nvim.man
    │   │   ├── restructuredtext.rst
    │   │   └── sample.lisp
    │   ├── clang
    │   │   ├── cli.c
    │   │   ├── cli.h
    │   │   ├── count.c
    │   │   ├── hello-world.c
    │   │   ├── hello.c
    │   │   ├── hello.cpp
    │   │   ├── issue-4.cc
    │   │   ├── learnc.c
    │   │   ├── learncpp.cpp
    │   │   ├── read.c
    │   │   └── vars.c
    │   ├── crystal
    │   │   ├── bindings.cr
    │   │   ├── greeter.cr
    │   │   └── learncrystal.cr
    │   ├── css
    │   │   ├── animation.2.html
    │   │   ├── animation.css
    │   │   ├── animation.html
    │   │   ├── animation.scss
    │   │   ├── bootstrap-grid.css
    │   │   ├── bootstrap.css
    │   │   ├── bootstrap.variables.scss
    │   │   ├── boxes.html
    │   │   ├── custom-properties.css
    │   │   ├── d4rkr00t.styl
    │   │   ├── drawer.css
    │   │   ├── operators.scss
    │   │   ├── test.css
    │   │   └── test.scss
    │   ├── elixir
    │   │   ├── animals.exs
    │   │   ├── blanks.exs
    │   │   ├── erlang
    │   │   │   ├── erlang.otp.lib.ssh.erl
    │   │   │   ├── erlang.rebar3.src.rebar_dir.erl
    │   │   │   ├── greeter.erl
    │   │   │   ├── hello.erl
    │   │   │   └── learnerlang.erl
    │   │   ├── failure.ex
    │   │   ├── file_system.ex
    │   │   ├── kv.ex
    │   │   ├── macro.ex
    │   │   ├── math.exs
    │   │   ├── oper.exs
    │   │   ├── oper2.ex
    │   │   ├── pipe.ex
    │   │   ├── reader.ex
    │   │   └── small_test.ex
    │   ├── elm
    │   │   ├── increment.elm
    │   │   ├── learnelm.elm
    │   │   ├── main.elm
    │   │   ├── player
    │   │   │   └── state.elm
    │   │   └── radio.elm
    │   ├── flat-files
    │   │   ├── json
    │   │   │   ├── italic.json
    │   │   │   └── package.json
    │   │   ├── quakes.csv
    │   │   ├── toml
    │   │   │   ├── Gopkg.toml
    │   │   │   └── example.toml
    │   │   └── yaml
    │   │   │   ├── appveyor.yml
    │   │   │   ├── cheat-sheet.yaml
    │   │   │   ├── dark-plus.yaml
    │   │   │   └── learn-x-in-y-minutes.yaml
    │   ├── go
    │   │   ├── accessor.go
    │   │   ├── bcrypt.go
    │   │   ├── bitmask.go
    │   │   ├── cases
    │   │   │   ├── args.go
    │   │   │   ├── channels.go
    │   │   │   ├── loop.go
    │   │   │   ├── params.go
    │   │   │   ├── ping-pong.go
    │   │   │   ├── receiver.go
    │   │   │   └── vars.go
    │   │   ├── channel.go
    │   │   ├── gohtml
    │   │   │   ├── calhoun.io.gotmpl
    │   │   │   ├── index.gohtml
    │   │   │   └── sample.gohtml
    │   │   ├── iota.go
    │   │   ├── issues
    │   │   │   ├── 00.go
    │   │   │   ├── 01.go
    │   │   │   └── 02.go
    │   │   ├── krypt.go
    │   │   ├── lissajous.go
    │   │   ├── moby.volume.store.go
    │   │   ├── mutex.go
    │   │   ├── regex1.go
    │   │   ├── regex2.go
    │   │   ├── rune.go
    │   │   ├── template.go
    │   │   └── type.go
    │   ├── graphql
    │   │   ├── directives.gql
    │   │   ├── interfaces.gql
    │   │   ├── scalars.gql
    │   │   └── unions.gql
    │   ├── haskell
    │   │   └── code.hs
    │   ├── html
    │   │   ├── embedded
    │   │   │   ├── eex
    │   │   │   │   ├── index.html.eex
    │   │   │   │   └── sample.html.eex
    │   │   │   ├── ejs
    │   │   │   │   ├── index.ejs
    │   │   │   │   ├── layout.ejs
    │   │   │   │   └── sample.ejs
    │   │   │   └── erb
    │   │   │   │   ├── sample.erb
    │   │   │   │   ├── sample.html.erb
    │   │   │   │   └── spree.html.erb
    │   │   ├── html
    │   │   │   └── html5-boilerplate.html
    │   │   └── misc
    │   │   │   ├── angular
    │   │   │       ├── app.component.html
    │   │   │       ├── hero-detail.component.html
    │   │   │       ├── hero-form.component.html
    │   │   │       ├── instructor-form.component.html
    │   │   │       ├── ng-for.component.html
    │   │   │       └── star.component.html
    │   │   │   ├── blade
    │   │   │       ├── loop.blade
    │   │   │       └── sample.blade
    │   │   │   ├── haml
    │   │   │       └── sample.haml
    │   │   │   ├── jade-pug
    │   │   │       ├── learn-x-in-y-minutes.pug
    │   │   │       └── sample.jade
    │   │   │   ├── jinja
    │   │   │       ├── idk.jinja
    │   │   │       └── uno.jinja
    │   │   │   ├── liquid
    │   │   │       └── product.liquid
    │   │   │   ├── sample.hbs
    │   │   │   ├── sample.vue.html
    │   │   │   ├── slim
    │   │   │       └── sample.slim
    │   │   │   ├── slimphp1.phtml
    │   │   │   └── smarty
    │   │   │       └── tumblr.smarty
    │   ├── java
    │   │   ├── Jenkinsfile
    │   │   ├── groovy
    │   │   │   └── learngroovy.groovy
    │   │   ├── java
    │   │   │   ├── LearnJava.java
    │   │   │   └── learn-x-in-y-minutes.java
    │   │   ├── kotlin
    │   │   │   ├── LearnKotlin.kt
    │   │   │   └── learn-x-in-y-minutes.kt
    │   │   └── scala
    │   │   │   └── learnscala.scala
    │   ├── markdown
    │   │   ├── cheatsheet.md
    │   │   ├── golang.md
    │   │   ├── gopl.ch3.md
    │   │   ├── maths.md
    │   │   ├── mermaid.md
    │   │   └── readme.md
    │   ├── proto
    │   │   ├── learn-x-in-y-minutes.proto
    │   │   ├── provenance
    │   │   │   ├── attribute.proto
    │   │   │   ├── query.proto
    │   │   │   └── tx.proto
    │   │   └── scratch.proto
    │   ├── python
    │   │   ├── call_count.py
    │   │   ├── dict.py
    │   │   ├── ship.py
    │   │   ├── slice.py
    │   │   ├── strangs.py
    │   │   └── types.py
    │   ├── ruby
    │   │   ├── Vagrantfile
    │   │   ├── cucumber
    │   │   │   ├── example.feature
    │   │   │   ├── food.feature
    │   │   │   └── is-it-friday-yet.feature
    │   │   ├── goot
    │   │   │   ├── args.rb
    │   │   │   ├── doc.rb
    │   │   │   ├── heredoc.rb
    │   │   │   ├── sample1.rb
    │   │   │   └── strings.rb
    │   │   ├── lambdas.rb
    │   │   ├── rails.lib.rails.rb
    │   │   ├── rails.railites.lib.engine.rb
    │   │   ├── regex.rb
    │   │   ├── sample2.rb
    │   │   ├── sass.engine.rb
    │   │   ├── spree.backend.helpers.rb
    │   │   └── yard.rb
    │   ├── rust
    │   │   ├── alpha.rs
    │   │   ├── data_structures.rs
    │   │   ├── fmt.rs
    │   │   ├── generic.rs
    │   │   ├── hashmap.rs
    │   │   ├── hello.rs
    │   │   ├── impl.rs
    │   │   ├── lifetime.rs
    │   │   ├── loop.rs
    │   │   ├── method.rs
    │   │   ├── minigrep
    │   │   │   ├── lib.rs
    │   │   │   └── main.rs
    │   │   ├── namespace.rs
    │   │   ├── num_func.rs
    │   │   ├── ripgrep.src.printer.rs
    │   │   ├── struccs.rs
    │   │   ├── type_test.rs
    │   │   ├── types.rs
    │   │   └── wasm.rs
    │   ├── shell
    │   │   ├── bash
    │   │   │   ├── .bash_profile
    │   │   │   ├── .inputrc
    │   │   │   ├── fzf.bash
    │   │   │   ├── git-completion.bash
    │   │   │   └── random.bash
    │   │   ├── sh
    │   │   │   ├── git-prompt.sh
    │   │   │   └── z.sh
    │   │   └── zsh
    │   │   │   ├── .fzf.zsh
    │   │   │   └── git-completion.zsh
    │   ├── swift
    │   │   ├── Row.swift
    │   │   ├── amethyst.layout.swift
    │   │   ├── correct
    │   │   │   ├── filespy.swift
    │   │   │   └── override.swift
    │   │   ├── iina.keybindingitem.swift
    │   │   ├── learnswift.swift
    │   │   ├── objec.swift
    │   │   └── operators.swift
    │   ├── viml
    │   │   ├── .vimrc
    │   │   ├── amix.basic.vimrc
    │   │   ├── amix.extended.vimrc
    │   │   ├── amix.filetypes.vimrc
    │   │   ├── amix.plugins.vimrc
    │   │   ├── go.vim
    │   │   ├── gruvbox.vim
    │   │   ├── javascript-node.snippets
    │   │   ├── json.snippets
    │   │   ├── man.vim
    │   │   ├── plug.vim
    │   │   ├── spf13.vimrc
    │   │   ├── test.vim
    │   │   └── viml.vim
    │   ├── xml
    │   │   ├── menu.xml
    │   │   └── nasa.xml
    │   └── yaml
    │   │   ├── C.sublime-syntax.yml
    │   │   ├── YAML.sublime-syntax.yml
    │   │   ├── database.yml
    │   │   ├── directive.yml
    │   │   ├── magic-modules.yml
    │   │   ├── oo.yml
    │   │   ├── preview.yml
    │   │   ├── sidekiq.standard.yml
    │   │   └── types.yml
    ├── tests
    │   ├── buildRules.test.ts
    │   └── example.test.ts
    └── tsconfig.test.json
├── todo.txt
└── tsconfig.json


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | indent_style = space
 5 | indent_size = 4
 6 | end_of_line = lf
 7 | charset = utf-8
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | 
11 | [*.md]
12 | indent_size = 2
13 | trim_trailing_whitespace = false
14 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: "[BUG] describe the bug"
 5 | labels: 'bug'
 6 | assignees: tcd
 7 | ---
 8 | 
 9 | # Bug
10 | 
11 | > Please replace everything in {curly brackets}
12 | 
13 | 
14 | ## Describe the bug
15 | 
16 | { A clear and concise description of what the bug is }
17 | 
18 | 
19 | ## To Reproduce
20 | 
21 | { A text/code snippet where the buggy behavior is present }
22 | 
23 | 
24 | ## Screenshots
25 | 
26 | { one or more screenshots to help explain your problem }
27 | 
28 | 
29 | ## Relevant Information
30 | 
31 | ### VSCode
32 | 
33 | - Track: { standard or insiders (if you don't know, it's standard) }
34 | - Version: { vscode version }
35 | - Extensions: { paste the output of `code --list-extensions` }
36 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_store
2 | Icon?
3 | **/tags
4 | node_modules/**
5 | .nyc_output
6 | !dist
7 | **/ignore
8 | 


--------------------------------------------------------------------------------
/.nycrc:
--------------------------------------------------------------------------------
1 | {
2 |     "extends": "@istanbuljs/nyc-config-typescript",
3 |     "all": true
4 | }
5 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - 10
4 | 


--------------------------------------------------------------------------------
/.vscode/bookmarks.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"files": [
 3 | 		{
 4 | 			"path": "node_modules/@types/vscode/index.d.ts",
 5 | 			"bookmarks": [
 6 | 				{
 7 | 					"line": 6465,
 8 | 					"column": 29,
 9 | 					"label": "vscode.ColorThemeKind"
10 | 				},
11 | 				{
12 | 					"line": 6474,
13 | 					"column": 30,
14 | 					"label": "vscode.ColorTheme"
15 | 				}
16 | 			]
17 | 		}
18 | 	]
19 | }


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | // A launch configuration that launches the extension inside a new window
 2 | {
 3 |     "version": "0.1.0",
 4 |     "configurations": [
 5 |         {
 6 |             "name": "Launch Extension",
 7 |             "type": "extensionHost",
 8 |             "request": "launch",
 9 |             "runtimeExecutable": "${execPath}",
10 |             "args": ["--extensionDevelopmentPath=${workspaceRoot}" ]
11 |         },
12 |         {
13 |             "type": "node",
14 |             "request": "launch",
15 |             "name": "Debug TypeScript Program",
16 |             "runtimeArgs": [
17 |                 "-r",
18 |                 "ts-node/register"
19 |             ],
20 |             "args": [
21 |                 "${workspaceFolder}/src/main.ts"
22 |             ]
23 |         },
24 |     ]
25 | }
26 | 


--------------------------------------------------------------------------------
/.vscodeignore:
--------------------------------------------------------------------------------
 1 | .github
 2 | .vscode
 3 | .nyc_output
 4 | ignore
 5 | node_modules
 6 | src
 7 | test
 8 | .editorconfig
 9 | .env
10 | .eslintrc.js
11 | .gitignore
12 | .nycrc
13 | # .travis.yml
14 | # .vscodeignore
15 | package-lock.json
16 | !package.json
17 | tsconfig.json
18 | !CHANGELOG.md
19 | !LICENSE.md
20 | !README.md
21 | todo.txt
22 | 
23 | **/tags # vim
24 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # [WIP] Contributing
 2 | 
 3 | > I recently rewrote the code for this theme.
 4 | >
 5 | > I'm in the process of updating this page accordingly.
 6 | 
 7 | The code is split up (mainly by language) into individual TypeScript files, which live in `src/theme/shared`.
 8 | So if you wanted to see the Ruby rules, for example, those are in `src/theme/shared/languages/ruby.js`.
 9 | 
10 | The language rules are exported as a single array from `src/theme/shared/languages/index.ts`.
11 | 
12 | Those files are imported, merged, and written out to `dist/themes/dark-plus-syntax-color-theme.json`
13 | 
14 | ## Building locally
15 | 
16 | 1. Clone the project
17 | 2. Run `npm install` to install development dependencies.
18 | 3. Run `npm run build` to build the theme file with the new changes.
19 | 
20 | ## Developing
21 | 
22 | It'll be helpful to install the [Highlight](https://github.com/fabiospampinato/vscode-highlight) plugin. \
23 | There are local vscode settings that configure it to color specific TypeScript constants to match the color values they represent.
24 | 
25 | 
26 | ## Resources & References
27 | 
28 | - [Microsoft/vscode-textmate](https://github.com/Microsoft/vscode-textmate)
29 | - [Scope Naming](https://www.sublimetext.com/docs/3/scope_naming.html)
30 | - [VSCode Theme Colors](https://code.visualstudio.com/api/references/theme-color)
31 | 
32 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # MIT License
 2 | 
 3 | > Copyright © 2022 Clay Dunston <dunstontc@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/dist/assets/128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tcd/dark-plus-syntax/944c366ba68d8b2a806ebd16495e3653a646ced7/dist/assets/128.png


--------------------------------------------------------------------------------
/dist/assets/512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tcd/dark-plus-syntax/944c366ba68d8b2a806ebd16495e3653a646ced7/dist/assets/512.png


--------------------------------------------------------------------------------
/dist/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tcd/dark-plus-syntax/944c366ba68d8b2a806ebd16495e3653a646ced7/dist/assets/logo.png


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./lib"
2 | export * from "./palettes"
3 | 


--------------------------------------------------------------------------------
/src/lib/build-rules.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette, TextMateRuleData, TextMateRule } from "@types"
 2 | 
 3 | export const buildRules = (palette: ThemeColorPalette, rules: TextMateRuleData[]): TextMateRule[] => {
 4 | 
 5 |     let result: TextMateRule[] = rules.map((rule) => {
 6 | 
 7 |         let textMateRule: TextMateRule = {
 8 |             scope:    rule.scopes,
 9 |             settings: {},
10 |         }
11 | 
12 |         if (rule.name) {
13 |             textMateRule.name = rule.name
14 |         }
15 | 
16 |         if (rule.fontStyle) {
17 |             textMateRule.settings.fontStyle = rule.fontStyle
18 |         }
19 | 
20 |         if (rule.foreground) {
21 |             textMateRule.settings.foreground = palette[rule.foreground]
22 |         }
23 | 
24 |         return textMateRule
25 |     })
26 | 
27 |     return result
28 | }
29 | 


--------------------------------------------------------------------------------
/src/lib/build-theme.ts:
--------------------------------------------------------------------------------
 1 | import { join } from "path"
 2 | 
 3 | import {
 4 |     ThemeSettings,
 5 |     VisualStudioCodeTheme,
 6 | } from "@types"
 7 | import {
 8 |     writeJsonFile,
 9 |     buildRules,
10 |     buildUiColors,
11 |     Config,
12 | } from "@lib"
13 | import {
14 |     Languages,
15 |     defaults,
16 |     ui,
17 | } from "@src/theme"
18 | 
19 | const outFilePath = (settings: ThemeSettings): string => {
20 |     const fileName = settings?.fileName ?? settings.name
21 |     let root = "./dist/theme"
22 |     if (Config.Development && Config.buildLocalExt) {
23 |         root = Config.localExtDistFolder
24 |     }
25 |     const file = `${fileName}-color-theme.json`
26 |     return join(root, file)
27 | }
28 | 
29 | export const buildTheme = (settings: ThemeSettings) => {
30 | 
31 |     const tokenColors = buildRules(settings.palette, [...defaults, ...Languages])
32 | 
33 |     const uiRules = settings.uiColors ?? ui
34 |     const uiColors = buildUiColors(settings.palette, uiRules)
35 | 
36 |     const themeData: VisualStudioCodeTheme = {
37 |         $schema:              "vscode://schemas/color-theme",
38 |         name:                 settings.name,
39 |         type:                 settings.type,
40 |         semanticHighlighting: false,
41 |         colors:               uiColors,
42 |         tokenColors,
43 |     }
44 | 
45 |     const outPath = outFilePath(settings)
46 | 
47 |     writeJsonFile(outPath, themeData)
48 | 
49 |     return null
50 | }
51 | 


--------------------------------------------------------------------------------
/src/lib/build-ui-colors.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette, VisualStudioCodeThemeColors } from "@types"
 2 | 
 3 | export const buildUiColors = (palette: ThemeColorPalette, uiColors: VisualStudioCodeThemeColors): VisualStudioCodeThemeColors => {
 4 | 
 5 |     let result = {}
 6 | 
 7 |     for (const [key, value] of Object.entries(uiColors)) {
 8 |         if (palette[value]) {
 9 |             result[key] = palette[value]
10 |         } else {
11 |             result[key] = value
12 |         }
13 |     }
14 | 
15 |     return result
16 | }
17 | 


--------------------------------------------------------------------------------
/src/lib/config.ts:
--------------------------------------------------------------------------------
 1 | import * as dotenv from "dotenv"
 2 | 
 3 | dotenv.config()
 4 | 
 5 | export enum NodeEnvironment {
 6 |     Development = "development",
 7 |     Test        = "test",
 8 |     Production  = "production",
 9 | }
10 | 
11 | export class Configuration {
12 | 
13 |     public env: NodeJS.ProcessEnv
14 |     public nodeEnvironment: NodeEnvironment
15 |     public localExtDistFolder: string
16 |     public buildLocalExt: boolean
17 | 
18 |     constructor() {
19 |         this.env = process.env
20 |         this.nodeEnvironment = process.env.NODE_ENV as NodeEnvironment
21 |         this.localExtDistFolder = process.env.LOCALLY_INSTALLED_THEME_FILE
22 |         this.buildLocalExt = (process.env.BUILD_LOCAL_EXT ?? "") === "true"
23 |     }
24 | 
25 |     public get Development() { return this.nodeEnvironment === NodeEnvironment.Development }
26 |     public get Test()        { return this.nodeEnvironment === NodeEnvironment.Test        }
27 |     public get Production()  { return this.nodeEnvironment === NodeEnvironment.Production  }
28 | 
29 | }
30 | 
31 | export const Config = new Configuration()
32 | 


--------------------------------------------------------------------------------
/src/lib/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./build-rules"
2 | export * from "./build-theme"
3 | export * from "./build-ui-colors"
4 | export * from "./config"
5 | export * from "./write-file"
6 | 


--------------------------------------------------------------------------------
/src/lib/write-file.ts:
--------------------------------------------------------------------------------
 1 | import * as fs from "fs"
 2 | 
 3 | export const writeJsonFile = (filePath: string, data: any, compact: boolean = false) => {
 4 |     try {
 5 |         let outData
 6 |         if (compact) {
 7 |             outData = JSON.stringify(data)
 8 |         } else {
 9 |             outData = JSON.stringify(data, null, 4)
10 |         }
11 |         fs.writeFileSync(filePath, outData)
12 |         console.log(`file written: ${filePath}`)
13 |     } catch (error) {
14 |        console.log(error)
15 |        process.exit(1)
16 |     }
17 | }
18 | 
19 | export const writeFile = (filePath: string, data: string) => {
20 |     try {
21 |         fs.writeFileSync(filePath, data)
22 |         console.log(`file written: ${filePath}`)
23 |     } catch (error) {
24 |        console.log(error)
25 |        process.exit(1)
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { buildTheme } from "@lib"
 2 | import {
 3 |     DarkPlus,
 4 |     LightPlus,
 5 |     DarkPlusHighContrast,
 6 |     LightPlusHighContrast,
 7 | } from "@src/themes"
 8 | 
 9 | const themes = [
10 |     DarkPlus,
11 |     LightPlus,
12 |     DarkPlusHighContrast,
13 |     LightPlusHighContrast,
14 | ]
15 | 
16 | themes.forEach(theme => buildTheme(theme))
17 | 


--------------------------------------------------------------------------------
/src/palettes/DarkPlusHighContrastPalette.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette } from "@types"
 2 | import { DarkPlusPalette } from "."
 3 | 
 4 | export const DarkPlusHighContrastPalette: ThemeColorPalette = {
 5 |     ...DarkPlusPalette,
 6 |     // UI
 7 |     Foreground: "#ffffff",
 8 |     Background: "#000000",
 9 |     Selection:  "#ffffff",
10 |     Primary:    "#f38518",
11 |     Secondary:  "#9cdcfe",
12 | }
13 | 


--------------------------------------------------------------------------------
/src/palettes/DarkPlusPalette.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette } from "@types"
 2 | 
 3 | export const DarkPlusPalette: ThemeColorPalette = {
 4 |     // Semantic
 5 |     RegExp:      "#d16969",
 6 |     Strings:     "#ce9178",
 7 |     Chars:       "#d7ba7d",
 8 |     Types:       "#4ec9b0",
 9 |     Variables:   "#9cdcfe",
10 |     Functions:   "#dcdcaa",
11 |     Numbers:     "#b5cea8",
12 |     Keywords:    "#569cd6",
13 |     FlowControl: "#c586c0",
14 |     Comments:    "#505050",
15 |     DocComments: "#608b4e",
16 |     Tags:        "#808080",
17 |     Noise:       "#404040",
18 |     // UI
19 |     Foreground:  "#d4d4d4",
20 |     Background:  "#1e1e1e",
21 |     // Selection:   "#add6ff26",
22 |     Selection:   "#264f78",
23 |     Primary:     "#608b4e",
24 |     Secondary:   "#007acc",
25 |     Error:       "#d16969",
26 |     Warning:     "#d7ba7d",
27 |     Info:        "#9cdcfe",
28 |     Success:     "#608b4e",
29 | }
30 | 


--------------------------------------------------------------------------------
/src/palettes/LightPlusHighContrastPalette.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette } from "@types"
 2 | import { LightPlusPalette } from "."
 3 | 
 4 | export const LightPlusHighContrastPalette: ThemeColorPalette = {
 5 |     ...LightPlusPalette,
 6 |     // UI
 7 |     Foreground: "#000000",
 8 |     Background: "#ffffff",
 9 |     // Primary: "#af00db",
10 |     // Error: "#b5200d",
11 |     // Selection: "#0f4a85",
12 | }
13 | 


--------------------------------------------------------------------------------
/src/palettes/LightPlusPalette.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette } from "@types"
 2 | import { DarkPlusPalette } from "."
 3 | 
 4 | export const LightPlusPalette: ThemeColorPalette = {
 5 |     // Semantic
 6 |     RegExp:      "#811f3f",
 7 |     Strings:     "#a31515",
 8 |     Chars:       "#ee0000",
 9 |     Types:       "#267f99",
10 |     Variables:   "#0070c1",
11 |     Functions:   "#795e26",
12 |     Numbers:     "#098658",
13 |     Keywords:    "#0000ff",
14 |     FlowControl: "#af00db",
15 |     Comments:    "#008000",
16 |     DocComments: "#008000",
17 |     Tags:        "#1e1e1e",
18 |     Noise:       "#a4a4a4",
19 |     // UI
20 |     Foreground:  "#1e1e1e",
21 |     Background:  "#d4d4d4",
22 |     Selection:   "#add6ff80",
23 |     Primary:     "#008000",
24 |     Secondary:   "#af00db",
25 |     Error:       "#811f3f",
26 |     Warning:     "#795e26",
27 |     Info:        "#0070c1",
28 |     Success:     "#008000",
29 | }
30 | 


--------------------------------------------------------------------------------
/src/palettes/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./DarkPlusPalette"
2 | export * from "./DarkPlusHighContrastPalette"
3 | export * from "./LightPlusPalette"
4 | export * from "./LightPlusHighContrastPalette"
5 | 


--------------------------------------------------------------------------------
/src/theme/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./shared"
2 | export * from "./ui"
3 | 
4 | 


--------------------------------------------------------------------------------
/src/theme/shared/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./defaults"
2 | export * from "./languages"
3 | export * from "./semanticTokenColors"
4 | export * from "./ui"
5 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/cfml.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | // ColdFusion Markup Language
 4 | //
 5 | // God help you if you have to use this. I wish you the best.
 6 | export const cfml: TextMateRuleData[] = [
 7 |     {
 8 |         scopes: [
 9 |             "comment.block.cfml",
10 |             "comment.line.cfml",
11 |         ],
12 |         foreground: ThemeColor.DocComments,
13 |     },
14 |     {
15 |         scopes: [
16 |             "punctuation.definition.template-expression.begin.cfml",
17 |             "punctuation.definition.template-expression.end.cfml",
18 |             "constant.character.hash.cfml.start", // ilich/vscode-coldfusion
19 |             "constant.character.hash.cfml.end",   // ilich/vscode-coldfusion
20 |         ],
21 |         foreground: ThemeColor.Keywords,
22 |     },
23 |     {
24 |         scopes: [
25 |             "meta.property.cfml",
26 |             "meta.property.constant.cfml",
27 |         ],
28 |         foreground: ThemeColor.Variables,
29 |     },
30 |     {
31 |         scopes: [
32 |             // "entity.name.tag.cfml",
33 |             "punctuation.accessor.cfml",
34 |         ],
35 |         foreground: ThemeColor.FlowControl,
36 |     },
37 |     {
38 |         scopes: [
39 |             "entity.name.tag.custom.cfml",
40 |         ],
41 |         foreground: ThemeColor.Types,
42 |     },
43 |     {
44 |         scopes: [
45 |             "entity.name.tag.cfml",
46 |         ],
47 |         foreground: ThemeColor.Keywords,
48 |     },
49 |     {
50 |         scopes: [
51 |             "punctuation.definition.tag.begin.cfml",
52 |             "punctuation.definition.tag.end.cfml",
53 |         ],
54 |         foreground: ThemeColor.Tags,
55 |     },
56 | ]
57 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/cpp.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const cpp: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "punctuation.separator.namespace.access.cpp",
 7 |         ],
 8 |         foreground: ThemeColor.Types,
 9 |     },
10 |     {
11 |         scopes: [
12 |             "source.cpp keyword.operator.bitwise.shift.c",
13 |         ],
14 |         foreground: ThemeColor.Keywords,
15 |     },
16 | ]
17 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/csv.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | /**
 4 |  * ## Extensions
 5 |  *
 6 |  * - [mechatroner/vscode_rainbow_csv](https://github.com/mechatroner/vscode_rainbow_csv)
 7 |  */
 8 | export const csv: TextMateRuleData[] = [
 9 |     {
10 |         scopes:     ["invalid.rainbow10"],
11 |         foreground: ThemeColor.FlowControl,
12 |     },
13 |     // FIXME: extra color
14 |     // {
15 |     //     scopes:    ["makup.bold.rainbow9"],
16 |     //     foreground: "#007acc",
17 |     // },
18 |     {
19 |         scopes:     ["entity.name.type.rainbow8"],
20 |         foreground: ThemeColor.Keywords,
21 |     },
22 |     {
23 |         scopes:     ["constant.numeric.rainbow7"],
24 |         foreground: ThemeColor.Variables,
25 |     },
26 |     {
27 |         scopes:     ["variable.parameter.rainbow6"],
28 |         foreground: ThemeColor.Types,
29 |     },
30 |     {
31 |         scopes:     ["string.rainbow5"],
32 |         foreground: ThemeColor.DocComments,
33 |     },
34 |     {
35 |         scopes:     ["comment.rainbow4"],
36 |         foreground: ThemeColor.Functions,
37 |     },
38 |     {
39 |         scopes:     ["entity.name.function.rainbow3"],
40 |         foreground: ThemeColor.Chars,
41 |     },
42 |     {
43 |         scopes:     ["keyword.rainbow2"],
44 |         foreground: ThemeColor.Strings,
45 |     },
46 |     {
47 |         scopes:     ["rainbow1"],
48 |         foreground: ThemeColor.RegExp,
49 |     },
50 | ]
51 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/dart.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const dart: TextMateRuleData[] = [
 4 |     {
 5 |         scopes:     ["keyword.control.new.dart"],
 6 |         foreground: ThemeColor.Keywords,
 7 |     },
 8 |     {
 9 |         scopes:     ["punctuation.terminator.dart"],
10 |         foreground: ThemeColor.Tags,
11 |     },
12 |     {
13 |         scopes:     ["punctuation.dot.dart"],
14 |         foreground: ThemeColor.FlowControl,
15 |     },
16 |     {
17 |         scopes:     ["meta.declaration.dart"],
18 |         foreground: ThemeColor.Variables,
19 |     },
20 | ]
21 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/dictionary.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const dictionary: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "string.word.dictionary",
 7 |         ],
 8 |         foreground: ThemeColor.DocComments,
 9 |     },
10 |     {
11 |         scopes: [
12 |             "variable.flagged.dictionary",
13 |             "keyword.operator.flag.dictionary",
14 |         ],
15 |         foreground: ThemeColor.RegExp,
16 |     },
17 | ]
18 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/erlang.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const erlang: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "punctuation.definition.placeholder.erlang",
 7 |             "constant.other.placeholder.erlang",
 8 |         ],
 9 |         foreground: ThemeColor.Chars,
10 |     },
11 |     {
12 |         scopes: [
13 |             "punctuation.separator.parameters.erlang",
14 |         ],
15 |         foreground: ThemeColor.Foreground,
16 |     },
17 |     {
18 |         scopes: [
19 |             "punctuation.section.directive.begin.erlang",
20 |             "punctuation.section.directive.end.erlang",
21 |             "punctuation.separator.module-function.erlang",
22 |             "punctuation.separator.record-field.erlang",
23 |             "punctuation.separator.list.erlang",
24 |             "keyword.operator.symbolic.erlang",
25 |             "punctuation.separator.clause-head-body.erlang",
26 |         ],
27 |         foreground: ThemeColor.FlowControl,
28 |     },
29 |     {
30 |         scopes: [
31 |             "punctuation.separator.clauses.erlang",
32 |             "punctuation.terminator.function.erlang",
33 |         ],
34 |         foreground: ThemeColor.Tags,
35 |     },
36 |     {
37 |         scopes: [
38 |             "punctuation.separator.function-arity.erlang",
39 |             "variable.language.omitted.erlang",
40 |             // "punctuation.separator.clause-head-body.erlang",
41 |             // "keyword.operator.symbolic.erlang",
42 |         ],
43 |         foreground: ThemeColor.Keywords,
44 |     },
45 |     {
46 |         scopes: [
47 |             "variable.other.erlang",
48 |             // "constant.other.symbol.unquoted.erlang",
49 |         ],
50 |         foreground: ThemeColor.Variables,
51 |     },
52 | ]
53 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/git.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const git: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "punctuation.definition.variable.begin.gitignore",
 7 |             "punctuation.definition.variable.end.gitignore",
 8 |         ],
 9 |         foreground: ThemeColor.Tags,
10 |     },
11 |     {
12 |         scopes: [
13 |             "support.function.git-rebase",
14 |         ],
15 |         foreground: ThemeColor.Variables,
16 |     },
17 |     {
18 |         scopes: [
19 |             "constant.sha.git-rebase",
20 |         ],
21 |         foreground: ThemeColor.Numbers,
22 |     },
23 | ]
24 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/google-sheets.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const googleSheets: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "source.sheets constant.character",
 7 |             "constant.character.format.google-sheets",
 8 |             "punctuation.definition.placeholder.google-sheets",
 9 |         ],
10 |         foreground: ThemeColor.Keywords,
11 |     },
12 |     {
13 |         scopes: [
14 |             "punctuation.definition.string.google-sheets",
15 |         ],
16 |         foreground: ThemeColor.Strings,
17 |     },
18 |     {
19 |         scopes: [
20 |             "variable.sheet.google-sheets",
21 |         ],
22 |         foreground: ThemeColor.Types,
23 |     },
24 |     {
25 |         scopes: [
26 |             "storage.type.reference.absolute.google-sheets",
27 |             "meta.placeholder.google-sheets",
28 |         ],
29 |         foreground: ThemeColor.Types,
30 |     },
31 | ]
32 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/graphql.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const graphql: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "entity.scalar.graphql",        // prisma-labs/vscode-graphql
 7 |             "entity.name.fragment.graphql", // prisma-labs/vscode-graphql
 8 |         ],
 9 |         foreground: ThemeColor.Types,
10 |     },
11 |     {
12 |         scopes: [
13 |             "punctuation.or.graphql",         // prisma-labs/vscode-graphql
14 |             "punctuation.assignment.graphql", // prisma-labs/vscode-graphql
15 |         ],
16 |         foreground: ThemeColor.FlowControl,
17 |     },
18 |     {
19 |         scopes: [
20 |             "graphql.description.SINGLELINE",            // kumarharsh/graphql-for-vscode
21 |             "string.block.description.graphql.DOCSTRING", // kumarharsh/graphql-for-vscode
22 |             "string.description.graphql",
23 |         ],
24 |         foreground: ThemeColor.DocComments,
25 |     },
26 | ]
27 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/haskell.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const haskell: TextMateRuleData[] = [
 4 |     // {
 5 |     //     scopes: [
 6 |     //         "constant.other.haskell",
 7 |     //     ],
 8 |     //    foreground: ThemeColor.Variables,
 9 |     // },
10 |     {
11 |         scopes: [
12 |             "meta.preprocessor.haskell",
13 |         ],
14 |         foreground: ThemeColor.DocComments,
15 |     },
16 |     {
17 |         scopes: [
18 |             "storage.type.haskell",
19 |             "support.other.module.haskell",
20 |         ],
21 |         foreground: ThemeColor.Types,
22 |     },
23 | ]
24 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/html/index.ts:
--------------------------------------------------------------------------------
1 | import { html } from "./html"
2 | 
3 | import { TextMateRuleData, ThemeColor } from "@types"
4 | 
5 | export const Html: TextMateRuleData[] = [
6 |     ...html,
7 | ]
8 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/ini.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const ini: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "comment.line.number-sign.ini",
 7 |             "punctuation.definition.entity.ini",
 8 |         ],
 9 |         foreground: ThemeColor.Tags,
10 |     },
11 |     {
12 |         scopes: [
13 |             "keyword.other.definition.ini",
14 |         ],
15 |         foreground: ThemeColor.Variables,
16 |     },
17 |     // {
18 |     //     scopes: ["entity.name.section.group-title.ini"],
19 |     //     foreground: ThemeColor.Keywords,
20 |     // },
21 |     {
22 |         scopes: [
23 |             "punctuation.separator.key-value.ini",
24 |         ],
25 |         foreground: ThemeColor.FlowControl,
26 |     },
27 | ]
28 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/java/groovy.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const groovy: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             // "constant.other.key.groovy",
 7 |             "source.groovy.embedded.source",
 8 |         ],
 9 |         foreground: ThemeColor.Variables,
10 |     },
11 |     {
12 |         scopes: [
13 |             "keyword.operator.assignment.groovy",
14 |             "keyword.operator.arithmetic.groovy",
15 |             "keyword.control.exception.groovy",
16 |         ],
17 |         foreground: ThemeColor.FlowControl,
18 |     },
19 |     {
20 |         scopes: [
21 |             "punctuation.section.embedded.groovy",
22 |             "constant.other.groovy",
23 |         ],
24 |         foreground: ThemeColor.Keywords,
25 |     },
26 |     {
27 |         scopes: [
28 |             "meta.method.groovy",
29 |             // "meta.method-call.groovy",
30 |         ],
31 |         foreground: ThemeColor.Functions,
32 |     },
33 |     {
34 |         scopes: [
35 |             "constant.character.escape.groovy",
36 |         ],
37 |         foreground: ThemeColor.Chars,
38 |     },
39 |     {
40 |         "name":  "Type declaration and references",
41 |         scopes: [
42 |             "storage.type.groovy",
43 |             "storage.type.annotation.groovy",
44 |             "storage.type.parameters.groovy",
45 |             "storage.type.generic.groovy",
46 |             "storage.type.object.array.groovy",
47 |             "storage.type.primitive.array.groovy",
48 |             "storage.type.primitive.groovy",
49 |         ],
50 |         foreground: ThemeColor.Types,
51 |     },
52 | ]
53 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/java/index.ts:
--------------------------------------------------------------------------------
 1 | import { groovy } from "./groovy"
 2 | import { java   } from "./java"
 3 | import { kotlin } from "./kotlin"
 4 | import { scala  } from "./scala"
 5 | 
 6 | import { TextMateRuleData, ThemeColor } from "@types"
 7 | 
 8 | export const Java: TextMateRuleData[] = [
 9 |     ...groovy,
10 |     ...java,
11 |     ...kotlin,
12 |     ...scala,
13 | ]
14 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/java/java.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const java: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "storage.modifier.import.java",
 7 |             "variable.language.wildcard.java",
 8 |             "storage.modifier.package.java",
 9 |         ],
10 |         foreground: ThemeColor.Foreground,
11 |     },
12 |     {
13 |         scopes: [
14 |             "variable.language.wildcard.java",
15 |             "punctuation.bracket.angle.java",
16 |             "variable.language.java",
17 |         ],
18 |         foreground: ThemeColor.Keywords,
19 |     },
20 |     {
21 |         scopes: [
22 |             "storage.type.annotation.java",
23 |             "punctuation.definition.annotation.java",
24 |         ],
25 |         foreground: ThemeColor.Functions,
26 |     },
27 |     {
28 |         scopes: [
29 |             // "storage.modifier.import.java punctuation.separator.java",
30 |             "meta.import.java storage.modifier.import.java",
31 |             "storage.type.annotation.java",
32 |             "storage.type.generic.java",
33 |             "storage.type.java",
34 |             "storage.type.object.array.java",
35 |             "storage.type.primitive.array.java",
36 |             "storage.type.primitive.java",
37 |             "storage.type.token.java",
38 |         ],
39 |         foreground: ThemeColor.Types,
40 |     },
41 |     {
42 |         scopes: [
43 |             "punctuation.separator.period.java",
44 |             "punctuation.separator.java",
45 |             "meta.import.java storage.modifier.import.java punctuation.separator.java",
46 |         ],
47 |         foreground: ThemeColor.FlowControl,
48 |     },
49 |     {
50 |         scopes: [
51 |             "variable.language.java",
52 |         ],
53 |         fontStyle: "italic",
54 |     },
55 | ]
56 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/java/kotlin.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | /**
 4 |  * ## Extensions
 5 |  *
 6 |  * - [fwcd/vscode-kotlin](https://github.com/fwcd/vscode-kotlin)
 7 |  *   - pretty bare bones
 8 |  */
 9 | export const kotlin: TextMateRuleData[] = [
10 |     {
11 |         scopes: [
12 |             "storage.type.builtin.kotlin",
13 |             "storage.type.builtin.collection.kotlin",
14 |             "entity.name.package.kotlin",
15 |         ],
16 |         foreground: ThemeColor.Types,
17 |     },
18 |     {
19 |         scopes: [
20 |             "meta.template.expression.kotlin",
21 |         ],
22 |         foreground: ThemeColor.Variables,
23 |     },
24 |     {
25 |         scopes: [
26 |             "keyword.hard.kotlin",
27 |             "keyword.operator.kotlin",
28 |         ],
29 |         foreground: ThemeColor.FlowControl,
30 |     },
31 | ]
32 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/java/scala.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const scala: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "storage.type.scala",
 7 |             "storage.type.primitive.scala",
 8 |             "meta.colon.scala",
 9 |         ],
10 |         foreground: ThemeColor.Types,
11 |     },
12 | ]
13 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/json.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const json: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "punctuation.definition.dictionary.begin.json",
 7 |             "punctuation.definition.dictionary.end.json",
 8 |             "punctuation.separator.dictionary.pair.json",
 9 |             "punctuation.separator.dictionary.key-value.json",
10 |             "punctuation.definition.array.begin.json",
11 |             "punctuation.definition.array.end.json",
12 |             "punctuation.separator.array.json",
13 |         ],
14 |         foreground: ThemeColor.Noise,
15 |     },
16 | ]
17 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/lisp.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const lisp: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "storage.type.function-type.lisp",
 7 |             "constant.language.lisp",
 8 |         ],
 9 |         foreground: ThemeColor.Keywords,
10 |     },
11 |     {
12 |         scopes: [
13 |             "keyword.constant.lisp",
14 |         ],
15 |         foreground: ThemeColor.Variables,
16 |     },
17 |     {
18 |         scopes: [
19 |             "keyword.control.lisp",
20 |         ],
21 |         foreground: ThemeColor.FlowControl,
22 |     },
23 | ]
24 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/makefile.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const makefile: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "comment.line.number-sign.makefile",
 7 |         ],
 8 |         foreground: ThemeColor.DocComments,
 9 |     },
10 |     {
11 |         scopes: [
12 |             "variable.other.makefile",
13 |         ],
14 |         foreground: ThemeColor.Variables,
15 |     },
16 |     {
17 |         scopes: [
18 |             "variable.language.makefile",
19 |         ],
20 |         foreground: ThemeColor.Keywords,
21 |     },
22 |     {
23 |         scopes: [
24 |             "entity.name.function.target.makefile",
25 |             "constant.character.escape.continuation.makefile",
26 |         ],
27 |         foreground: ThemeColor.Functions,
28 |     },
29 |     {
30 |         scopes: [
31 |             "punctuation.separator.key-value.makefile",
32 |             "support.function.foreach.makefile",
33 |             "keyword.control.ifeq.makefile",
34 |             "keyword.control.endif.makefile",
35 |             "constant.character.escape.continuation.makefile",
36 |         ],
37 |         foreground: ThemeColor.FlowControl,
38 |     },
39 |     // =========================================================================
40 |     // CMake
41 |     // =========================================================================
42 |     {
43 |         scopes: [
44 |             "storage.source.cmake",
45 |         ],
46 |         foreground: ThemeColor.Variables,
47 |     },
48 | ]
49 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/nginx.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const nginx: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "source.nginx constant.character.brace",
 7 |             "source.nginx constant.character.paren",
 8 |         ],
 9 |         foreground: ThemeColor.Foreground,
10 |     },
11 |     {
12 |         scopes: [
13 |             "source.nginx constant.character.brace",
14 |             "source.nginx constant.character.end",
15 |         ],
16 |         foreground: ThemeColor.Tags,
17 |     },
18 |     // {
19 |     //     scopes: [
20 |     //         // "source.nginx ",
21 |     //         "source.nginx constant.language.directive.module.events",
22 |     //         "source.nginx constant.language.directive.module.main",
23 |     //         "source.nginx constant.language.module.http.log",
24 |     //         "source.nginx constant.language.module.http.fastcgi",
25 |     //         "source.nginx constant.language.directive.module.http",
26 |     //
27 |     //     ],
28 |     //     foreground: ThemeColor.Keywords,
29 |     // },
30 |     // {
31 |     //     scopes: [
32 |     //         // "source.nginx ",
33 |     //         // "source.nginx constant.language.directive.module.events",
34 |     //         // "source.nginx constant.language.module.http.log",
35 |     //         // "source.nginx constant.language.module.http.fastcgi",
36 |     //         // // "source.nginx constant.language.directive.module.http",
37 |     //     ],
38 |     //     foreground: ThemeColor.Variables,
39 |     // },
40 | ]
41 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/org-mode.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const orgMode: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "source.org comment.line",
 7 |             "source.org punctuation.definition.comment",
 8 |             "meta.link.inline.org punctuation.definition.string.begin.org",
 9 |             "meta.link.inline.org punctuation.definition.string.end.org",
10 |             "meta.link.inline.org markup.underline.link.org",
11 |         ],
12 |         foreground: ThemeColor.Tags,
13 |     },
14 | ]
15 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/protobuf.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | /**
 4 |  * Protocol Buffers
 5 |  *
 6 |  * ## Extensions
 7 |  *
 8 |  * - [zxh0/vscode-proto3](https://github.com/zxh0/vscode-proto3)
 9 |  */
10 | export const protobuf: TextMateRuleData[] = [
11 |     {
12 |         scopes: [
13 |             "constant.language.proto",
14 |             "keyword.other.proto",
15 |             "storage.type.proto",
16 |             "storage.modifier.proto",
17 |             "punctuation.definition.typeparameters.begin.proto",
18 |             "punctuation.definition.typeparameters.end.proto",
19 |         ],
20 |         foreground: ThemeColor.Keywords,
21 |     },
22 |     {
23 |         scopes: [
24 |             "entity.name.class.proto",
25 |             "entity.name.class.message.proto",
26 |         ],
27 |         foreground: ThemeColor.Types,
28 |     },
29 |     {
30 |         scopes: [
31 |             "punctuation.separator.key-value.proto",
32 |         ],
33 |         foreground: ThemeColor.FlowControl,
34 |     },
35 |     {
36 |         scopes: [
37 |             "variable.other.proto",
38 |         ],
39 |         foreground: ThemeColor.Variables,
40 |     },
41 |     {
42 |         scopes: [
43 |             "constant.numeric.proto",
44 |         ],
45 |         foreground: ThemeColor.Numbers,
46 |     },
47 | ]
48 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/smarty.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const smarty: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "support.function.built-in.smarty",
 7 |         ],
 8 |         // foreground: ThemeColor.Keywords,
 9 |         foreground: ThemeColor.FlowControl,
10 |     },
11 |     {
12 |         scopes: [
13 |             "source.smarty punctuation.section.embedded.begin.smarty",
14 |             "source.smarty punctuation.section.embedded.end.smarty",
15 |         ],
16 |         foreground: ThemeColor.Tags,
17 |     },
18 |     {
19 |         scopes: [
20 |             "source.smarty",
21 |         ],
22 |         foreground: ThemeColor.Types,
23 |     },
24 | ]
25 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/styles/index.ts:
--------------------------------------------------------------------------------
 1 | import { css } from "./css"
 2 | import { stylus } from "./stylus"
 3 | import { styledComponents } from "./styled-components"
 4 | 
 5 | import { TextMateRuleData, ThemeColor } from "@types"
 6 | 
 7 | export const Styles: TextMateRuleData[] = [
 8 |     ...css,
 9 |     ...stylus,
10 |     ...styledComponents,
11 | ]
12 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/styles/styled-components.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const styledComponents: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "punctuation.semi-colon.css",
 7 |             "meta.brace.curly.css",
 8 |         ],
 9 |         foreground: ThemeColor.Tags,
10 |     },
11 |     {
12 |         scopes: [
13 |             "constant.hex.css",
14 |             "meta.identifier.css",
15 |         ],
16 |         foreground: ThemeColor.Strings,
17 |     },
18 |     {
19 |         scopes: [
20 |             "constant.percentage.units.css",
21 |             "constant.length.units.css",
22 |             "entity.other.keyframe-offset.percentage.css",
23 |         ],
24 |         foreground: ThemeColor.Numbers,
25 |     },
26 |     {
27 |         scopes: [
28 |             "entity.name.tag.styledcss.js",
29 |         ],
30 |         foreground: ThemeColor.Types,
31 |     },
32 | ]
33 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/styles/stylus.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const stylus: TextMateRuleData[] = [
 4 |     {
 5 |         scopes:    ["punctuation.definition.keyword.stylus"],
 6 |         foreground: ThemeColor.FlowControl,
 7 |     },
 8 |     {
 9 |         scopes:    ["meta.interpolation.stylus"],
10 |         foreground: ThemeColor.Variables,
11 |     },
12 |     {
13 |         scopes:    ["variable.stylus"],
14 |         foreground: ThemeColor.Types,
15 |     },
16 |     {
17 |         scopes:    ["entity.other.attribute-name.parent-selector-suffix.stylus"],
18 |         foreground: ThemeColor.Chars,
19 |     },
20 |     {
21 |         scopes:    ["meta.interpolation.stylus meta.brace.curly"],
22 |         foreground: ThemeColor.Keywords,
23 |     },
24 | ]
25 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/swift.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const swift: TextMateRuleData[] = [
 4 |     {
 5 |         scopes:    ["comment.punctuation.comma.swift"],
 6 |         foreground: ThemeColor.Foreground,
 7 |     },
 8 |     {
 9 |         scopes: [
10 |             "keyword.statement.swift",
11 |         ],
12 |         foreground: ThemeColor.FlowControl,
13 |     },
14 |     {
15 |         scopes: [
16 |             "string-interpolation keyword.operator.swift",
17 |             "punctuation.section.embedded.begin.swift",
18 |             "punctuation.section.embedded.end.swift",
19 |         ],
20 |         foreground: ThemeColor.Keywords,
21 |     },
22 |     {
23 |         scopes: [
24 |             "variable.language.self.swift",
25 |             "keyword.expressions-and-types.swift",
26 |         ],
27 |         foreground: ThemeColor.Keywords,
28 |         fontStyle:  "italic",
29 |     },
30 |     {
31 |         scopes: [
32 |             "meta.embedded.line.swift",
33 |         ],
34 |         foreground: ThemeColor.Variables,
35 |     },
36 | ]
37 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/terraform.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const terraform: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "entity.name.section.terraform",
 7 |         ],
 8 |         foreground: ThemeColor.FlowControl,
 9 |     },
10 |     {
11 |         scopes: [
12 |             "keyword.other.section.begin.terraform",
13 |             "keyword.other.section.end.terraform",
14 |             "keyword.other.function.inline.terraform",
15 |         ],
16 |         foreground: ThemeColor.Functions,
17 |     },
18 |     {
19 |         scopes: [
20 |             "storage.type.function.terraform",
21 |             "entity.tag.embedded.start.terraform",
22 |             "entity.tag.embedded.end.terraform",
23 |         ],
24 |         foreground: ThemeColor.Keywords,
25 |     },
26 |     {
27 |         scopes: [
28 |             "entity.other.attribute-name.terraform",
29 |             "source.terraform.embedded.source",
30 |         ],
31 |         foreground: ThemeColor.Variables,
32 |     },
33 | ]
34 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/todo-txt.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | export const todoTxt: TextMateRuleData[] = [
 4 |     {
 5 |         scopes: [
 6 |             "meta.item.done.todo",
 7 |             "meta.item.done.todo variable.priority.todo",
 8 |             "meta.item.done.todo variable.other",
 9 |             "meta.item.done.todo constant.numeric.date.todo",
10 |             "meta.item.done.todo string.quoted.single.todo",
11 |             "meta.item.done.todo string.quoted.double.todo",
12 |         ],
13 |         foreground: ThemeColor.DocComments,
14 |     },
15 |     {
16 |         scopes: [
17 |             "constant.numeric.date.todo",
18 |         ],
19 |         foreground: ThemeColor.Numbers,
20 |     },
21 |     {
22 |         scopes: [
23 |             "string.quoted.single.todo",
24 |             "string.quoted.double.todo",
25 |         ],
26 |         foreground: ThemeColor.Types,
27 |     },
28 |     {
29 |         scopes: [
30 |             "meta.item.priority.a.todo",
31 |         ],
32 |         foreground: ThemeColor.Error,
33 |     },
34 |     {
35 |         scopes: [
36 |             "meta.item.priority.b.todo",
37 |         ],
38 |         foreground: ThemeColor.RegExp,
39 |     },
40 |     {
41 |         scopes: [
42 |             "meta.item.priority.c.todo",
43 |         ],
44 |         foreground: ThemeColor.Strings,
45 |     },
46 |     {
47 |         scopes: [
48 |             "meta.item.priority.d.todo",
49 |         ],
50 |         foreground: ThemeColor.Chars,
51 |     },
52 |     {
53 |         scopes: [
54 |             "meta.item.priority.e.todo",
55 |         ],
56 |         foreground: ThemeColor.Functions,
57 |     },
58 | ]
59 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/toml.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | /**
 4 |  * ## Extensions
 5 |  *
 6 |  * - [tamasfe/taplo](https://github.com/tamasfe/taplo)
 7 |  */
 8 | export const toml: TextMateRuleData[] = [
 9 |     {
10 |         scopes: [
11 |             "punctuation.definition.array.toml",
12 |             "punctuation.separator.array.toml",
13 |         ],
14 |         foreground: ThemeColor.Foreground,
15 |     },
16 |     {
17 |         scopes: [
18 |             "keyword.key.toml",
19 |         ],
20 |         foreground: ThemeColor.Variables,
21 |     },
22 |     {
23 |         scopes: [
24 |             "constant.other.datetime-with-timezone.toml",
25 |             "constant.other.time.datetime.offset.toml",
26 |         ],
27 |         foreground: ThemeColor.Numbers,
28 |     },
29 |     {
30 |         scopes: [
31 |             "meta.tag.table.toml",
32 |             "punctuation.eq.toml",
33 |             "punctuation.definition.keyValuePair.toml",
34 |         ],
35 |         foreground: ThemeColor.FlowControl,
36 |     },
37 |     {
38 |         scopes: [
39 |             "entity.other.attribute-name.table.array.toml",
40 |             "entity.other.attribute-name.table.toml",
41 |             "constant.other.boolean.toml",
42 |         ],
43 |         foreground: ThemeColor.Keywords,
44 |     },
45 |     {
46 |         scopes: [
47 |             // "source.toml",
48 |             "punctuation.definition.table.toml",
49 |             "punctuation.definition.array.table.toml",
50 |         ],
51 |         foreground: ThemeColor.Tags,
52 |     },
53 | ]
54 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/vcard.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * - [cstrachan88/vscode-vcard](https://github.com/cstrachan88/vscode-vcard)
 3 |  */
 4 | import { TextMateRuleData, ThemeColor } from "@types"
 5 | 
 6 | export const vcard: TextMateRuleData[] = [
 7 |     {
 8 |         scopes: [
 9 |             "source.vcard support.function.vcard",
10 |         ],
11 |         foreground: ThemeColor.FlowControl,
12 |     },
13 |     {
14 |         scopes: [
15 |             "source.vcard support.function.vcard keyword.control.property.vcard",
16 |         ],
17 |         foreground: ThemeColor.Variables,
18 |     },
19 |     {
20 |         scopes: [
21 |             "source.vcard support.function.vcard entity.name.type.attribute.vcard",
22 |         ],
23 |         foreground: ThemeColor.Strings,
24 |     },
25 |     {
26 |         scopes: [
27 |             "source.vcard support.function.vcard keyword.other.expansion.property.vcard",
28 |         ],
29 |         foreground: ThemeColor.Keywords,
30 |     },
31 | ]
32 | 


--------------------------------------------------------------------------------
/src/theme/shared/languages/viml.ts:
--------------------------------------------------------------------------------
 1 | import { TextMateRuleData, ThemeColor } from "@types"
 2 | 
 3 | /**
 4 |  * ## Extensions
 5 |  *
 6 |  * - [dunstontc/viml](https://github.com/dunstontc/viml)
 7 |  */
 8 | export const viml: TextMateRuleData[] = [
 9 |     {
10 |         scopes: [
11 |             // "constant.character",
12 |             "constant.character.map.rhs.viml",
13 |             "constant.character.map.special.viml",
14 |             "constant.character.map.key.viml",
15 |             "constant.character.map.key.fn.viml",
16 |             "constant.character.map.viml",
17 |         ],
18 |         foreground: ThemeColor.Chars,
19 |     },
20 |     {
21 |         scopes: [
22 |             "punctuation.definition.map.viml",
23 |     ],
24 |         foreground: ThemeColor.Tags,
25 |     },
26 | ]
27 | 


--------------------------------------------------------------------------------
/src/theme/shared/semanticTokenColors.ts:
--------------------------------------------------------------------------------
1 | import { ThemeColor } from "@types"
2 | 
3 | export const semanticTokenColors = {
4 |     "newOperator":   ThemeColor.FlowControl,
5 |     "stringLiteral": ThemeColor.Strings,
6 |     "customLiteral": ThemeColor.Functions,
7 |     "numberLiteral": ThemeColor.Numbers,
8 | }
9 | 


--------------------------------------------------------------------------------
/src/theme/ui/dark-ui.ts:
--------------------------------------------------------------------------------
 1 | import { VisualStudioCodeThemeColors, ThemeColor } from "@types"
 2 | import { ui as defaultUiColors } from "@src/theme/shared/ui"
 3 | 
 4 | export const DarkUi: VisualStudioCodeThemeColors = {
 5 |     ...defaultUiColors,
 6 |     "statusBar.background":          "#303030",
 7 |     "statusBar.noFolderBackground":  "#303030",
 8 |     "statusBar.debuggingBackground": "#303030",
 9 |     // "editor.lineHighlightBorder":    ThemeColor.Selection,
10 | }
11 | 


--------------------------------------------------------------------------------
/src/theme/ui/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./dark-ui"
2 | export * from "./light-ui"
3 | export * from "./dark-high-contrast-ui"
4 | export * from "./light-high-contrast-ui"
5 | 


--------------------------------------------------------------------------------
/src/theme/ui/light-high-contrast-ui.ts:
--------------------------------------------------------------------------------
 1 | import { VisualStudioCodeThemeColors, ThemeColor } from "@types"
 2 | import { ui as defaultUiColors } from "@src/theme/shared/ui"
 3 | 
 4 | export const LightHighContrastUi: VisualStudioCodeThemeColors = {
 5 |     ...defaultUiColors,
 6 |     // "sideBar.background": ThemeColor.Background,
 7 |     "activityBar.background": ThemeColor.Background,
 8 |     "activityBar.foreground": ThemeColor.Foreground,
 9 |     "statusBar.background":   ThemeColor.Background,
10 |     "statusBar.foreground":   ThemeColor.Foreground,
11 |     "list.activeSelectionIconForeground": "#ffffff",
12 |     // "editor.selectionForeground": ThemeColor.Foreground,
13 |     // "selection.background": ThemeColor.Selection,
14 | }
15 | 


--------------------------------------------------------------------------------
/src/theme/ui/light-ui.ts:
--------------------------------------------------------------------------------
 1 | import { VisualStudioCodeThemeColors, ThemeColor } from "@types"
 2 | import { ui as defaultUiColors } from "@src/theme/shared/ui"
 3 | 
 4 | export const LightUi: VisualStudioCodeThemeColors = {
 5 |     ...defaultUiColors,
 6 |     // "sideBar.background": ThemeColor.Background,
 7 |     "activityBar.background": ThemeColor.Background,
 8 |     "activityBar.foreground": ThemeColor.Foreground,
 9 |     "statusBar.background":   ThemeColor.Background,
10 |     "statusBar.foreground":   ThemeColor.Foreground,
11 | }
12 | 


--------------------------------------------------------------------------------
/src/themes/DarkPlus.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeSettings, ThemeType } from "@types"
 2 | import { DarkPlusPalette } from "@src/palettes"
 3 | import { DarkUi } from "@src/theme"
 4 | 
 5 | export const DarkPlus: ThemeSettings = {
 6 |     name:     "dark-plus-syntax",
 7 |     type:     ThemeType.Dark,
 8 |     palette:  DarkPlusPalette,
 9 |     uiColors: DarkUi,
10 | }
11 | 


--------------------------------------------------------------------------------
/src/themes/DarkPlusHighContrast.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeSettings, ThemeType } from "@types"
 2 | import { DarkPlusHighContrastPalette } from "@src/palettes"
 3 | import { DarkHighContrastUi } from "@src/theme"
 4 | 
 5 | export const DarkPlusHighContrast: ThemeSettings = {
 6 |     name:     "dark-plus-syntax (high contrast)",
 7 |     fileName: "dark-plus-syntax-high-contrast",
 8 |     type:     ThemeType.HighContrast,
 9 |     palette:  DarkPlusHighContrastPalette,
10 |     uiColors: DarkHighContrastUi,
11 | }
12 | 


--------------------------------------------------------------------------------
/src/themes/LightPlus.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeSettings, ThemeType } from "@types"
 2 | import { LightPlusPalette } from "@src/palettes"
 3 | import { LightUi } from "@src/theme"
 4 | 
 5 | export const LightPlus: ThemeSettings = {
 6 |     name:     "light-plus-syntax",
 7 |     type:     ThemeType.Light,
 8 |     palette:  LightPlusPalette,
 9 |     uiColors: LightUi,
10 | }
11 | 


--------------------------------------------------------------------------------
/src/themes/LightPlusHighContrast.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeSettings, ThemeType } from "@types"
 2 | import { LightPlusHighContrastPalette } from "@src/palettes"
 3 | import { LightHighContrastUi } from "@src/theme"
 4 | 
 5 | export const LightPlusHighContrast: ThemeSettings = {
 6 |     name:     "light-plus-syntax (high contrast)",
 7 |     fileName: "light-plus-syntax-high-contrast",
 8 |     type:     ThemeType.HighContrast,
 9 |     palette:  LightPlusHighContrastPalette,
10 |     uiColors: LightHighContrastUi,
11 | }
12 | 


--------------------------------------------------------------------------------
/src/themes/index.ts:
--------------------------------------------------------------------------------
1 | export * from "./DarkPlus"
2 | export * from "./DarkPlusHighContrast"
3 | export * from "./LightPlus"
4 | export * from "./LightPlusHighContrast"
5 | 


--------------------------------------------------------------------------------
/src/types/ColorMap.ts:
--------------------------------------------------------------------------------
1 | export type ColorMap = {
2 |     [key: string]: string
3 | }
4 | 


--------------------------------------------------------------------------------
/src/types/FontStyleString.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * [vscode - TokenClassificationRegistry](https://github.com/microsoft/vscode/blob/main/src/vs/platform/theme/common/tokenClassificationRegistry.ts#L308-L322)
 3 |  */
 4 | export type FontStyleString =
 5 |     | "italic"
 6 |     | "bold"
 7 |     | "underline"
 8 |     | "strikethrough"
 9 |     | "italic bold"
10 |     | "italic underline"
11 |     | "italic strikethrough"
12 |     | "bold underline"
13 |     | "bold strikethrough"
14 |     | "underline strikethrough"
15 |     | "italic bold underline"
16 |     | "italic bold strikethrough"
17 |     | "italic underline strikethrough"
18 |     | "bold underline strikethrough"
19 |     | "italic bold underline strikethrough"
20 | 


--------------------------------------------------------------------------------
/src/types/HexColorString.ts:
--------------------------------------------------------------------------------
1 | export type HexColorString = string
2 | 


--------------------------------------------------------------------------------
/src/types/TextMateRule.ts:
--------------------------------------------------------------------------------
 1 | import { TokenScopes, TokenStyleData } from "@types"
 2 | 
 3 | /**
 4 |  * A TextMate theming rule used to set colors and styles.
 5 |  */
 6 | export class TextMateRule {
 7 |     /**
 8 |      * Description of the rule. Optional.
 9 |      */
10 |     name?: string
11 |     /**
12 |      * Scope selector against which this rule matches.
13 |      */
14 |     scope: TokenScopes
15 |     /**
16 |      * Colors and styles for the rule.
17 |      */
18 |     settings: TokenStyleData
19 | }
20 | 


--------------------------------------------------------------------------------
/src/types/ThemeType.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * [colorThemeData.ts](https://github.com/microsoft/vscode/blob/5c2b7b83dfc116c660acea9728129e199ae9f2fd/src/vs/workbench/services/themes/common/colorThemeData.ts#L770)
3 |  */
4 | export enum ThemeType {
5 |     Dark         = "dark",
6 |     Light        = "light",
7 |     HighContrast = "hc",
8 | }
9 | 


--------------------------------------------------------------------------------
/src/types/TokenScopes.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * Scope selector against which a rule matches.
3 |  */
4 | export type TokenScopes = string[]
5 | 


--------------------------------------------------------------------------------
/src/types/TokenStyleData.ts:
--------------------------------------------------------------------------------
 1 | import { FontStyleString, HexColorString } from "@types"
 2 | 
 3 | /**
 4 |  * Colors and styles for a rule.
 5 |  *
 6 |  * At least one value (`foreground` or `fontStyle`) must be present.
 7 |  */
 8 | export interface TokenStyleData {
 9 |     /**
10 |      * Foreground color
11 |      */
12 |     foreground?: HexColorString | undefined
13 |     /**
14 |      * Any combination of the following values:
15 |      *
16 |      * - "italic"
17 |      * - "bold"
18 |      * - "underline"
19 |      * - "strikethrough"
20 |      *
21 |      * An empty string unsets inherited settings.
22 |      */
23 |     fontStyle?: FontStyleString | undefined
24 | }
25 | 


--------------------------------------------------------------------------------
/src/types/custom/TextMateRuleData.ts:
--------------------------------------------------------------------------------
 1 | import { FontStyleString, ThemeColor, TokenScopes } from "@types"
 2 | 
 3 | export interface TextMateRuleData {
 4 |     name?: string
 5 |     scopes: TokenScopes
 6 |     /**
 7 |      * Foreground color
 8 |      */
 9 |     foreground?: ThemeColor
10 |     /**
11 |      * Any combination of the following values:
12 |      *
13 |      * - "italic"
14 |      * - "bold"
15 |      * - "underline"
16 |      * - "strikethrough"
17 |      */
18 |     fontStyle?: FontStyleString | undefined
19 | }
20 | 


--------------------------------------------------------------------------------
/src/types/custom/ThemeColorPalette.ts:
--------------------------------------------------------------------------------
1 | import { ThemeColor } from "@types"
2 | 
3 | /**
4 |  * All the colors we need to make a theme*. (Save for the UI...)
5 |  */
6 | export type ThemeColorPalette = Record<ThemeColor, string>
7 | 


--------------------------------------------------------------------------------
/src/types/custom/ThemeSettings.ts:
--------------------------------------------------------------------------------
 1 | import { ThemeColorPalette, ThemeType, VisualStudioCodeThemeColors } from "@types"
 2 | 
 3 | export interface ThemeSettings {
 4 |     name: string
 5 |     fileName?: string
 6 |     type: ThemeType
 7 |     palette: ThemeColorPalette
 8 |     uiColors?: VisualStudioCodeThemeColors
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/types/custom/index.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * These types are used to build color theme JSON files.
3 |  */
4 | 
5 | export * from "./TextMateRuleData"
6 | export * from "./ThemeColor"
7 | export * from "./ThemeColorPalette"
8 | export * from "./ThemeSettings"
9 | 


--------------------------------------------------------------------------------
/src/types/index.ts:
--------------------------------------------------------------------------------
 1 | export * from "./custom"
 2 | 
 3 | export * from "./ColorMap"
 4 | export * from "./FontStyleString"
 5 | export * from "./HexColorString"
 6 | export * from "./TextMateRule"
 7 | export * from "./ThemeType"
 8 | export * from "./TokenScopes"
 9 | export * from "./TokenStyleData"
10 | export * from "./VisualStudioCodeTheme"
11 | export * from "./VisualStudioCodeThemeColors"
12 | 


--------------------------------------------------------------------------------
/test/samples/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "editor.semanticHighlighting.enabled": true,
 3 |     "python.pythonPath": "/usr/local/bin/python3",
 4 |     "python.linting.enabled": false,
 5 |     "solargraph.diagnostics": false,
 6 |     "ruby.lint": {
 7 |         "rubocop": false,
 8 |         "fasterer": false,
 9 |     },
10 |     "java.configuration.maven.notCoveredPluginExecutionSeverity": "ignore",
11 |     "java.errors.incompleteClasspath.severity": "ignore",
12 |     "files.associations": {
13 |         ".{aliases,path,viminfo}": "shellscript",
14 |         "*.blade": "blade",
15 |         ".{babelrc,eslintrc,postcssrc,stylelintrc}": "jsonc",
16 |         "cargo.lock": "toml",
17 |         "Dockerfile.*": "dockerfile",
18 |         "Cargo.lock": "toml",
19 |         ".env": "properties",
20 |         "*.el": "lisp",
21 |         "*.ipynb": "json",
22 |         "Gemfile.lock": "gemfile",
23 |         "mix.lock": "elixir",
24 |         "*.mak": "makefile",
25 |         "Gopkg.lock": "toml",
26 |         "*.{jsonc,json5,JSON-tmLanguage}": "jsonc",
27 |         "*.{jinja,jinja2}": "html",
28 |         ".{nvimrc,ideavimrc}": "viml",
29 |         "*.plist": "xml",
30 |         "*.ractive": "javascript",
31 |         "shard.lock": "yaml",
32 |         "*.psql": "sql",
33 |         "*.tmpl": "gohtml",
34 |         ".{dockerignore,eslintignore,npmignore,vscodeignore}": "gitignore",
35 |         "algorithm": "c",
36 |         "chrono": "c"
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/test/samples/CS/AnswerQue.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | 
 4 | namespace GitKata.Shared
 5 | {
 6 | 
 7 |     public class AnswerQueue<T> : Queue<T> where T : IGradable
 8 |     {
 9 |         private readonly int _size;
10 | 
11 |         public decimal Grade { get{ return !this.Any() ? 0 :  this.Average(x => x.Grade); } }
12 | 
13 |         /// <summary>
14 |         /// Stack that cannot exceed it's size
15 |         /// </summary>
16 |         /// <param name="size"> Maximum size of the queue </param>
17 |         public AnswerQueue(int size)
18 |         {
19 |             this._size = size;
20 |         }
21 | 
22 |         /// <summary>
23 |         /// Hides the default implementation of queue Enqueue
24 |         /// </summary>
25 |         /// <param name="item"></param>
26 |         public new void Enqueue(T item)
27 |         {
28 |             if (this.Count >= _size) base.Dequeue();
29 |             base.Enqueue(item);
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/test/samples/CS/TrueFalse.cs:
--------------------------------------------------------------------------------
 1 | namespace GitKata.Shared
 2 | {
 3 |     /// <summary>
 4 |     /// An Answer that only has two outcomes: true or false
 5 |     /// </summary>
 6 |     public class TrueFalseAnswer : IGradable
 7 |     {
 8 |         /// <summary>
 9 |         /// ctor
10 |         /// </summary>
11 |         /// <param name="correct">The result of the Answer.  True or False</param>
12 |         public TrueFalseAnswer(bool correct)
13 |         {
14 |             Correct = correct;
15 |         }
16 | 
17 |         /// <summary>
18 |         /// Whether or not the Answer was correct
19 |         /// </summary>
20 |         public bool Correct { get; set; }
21 | 
22 |         public decimal Grade { get { return Correct ?  100 : 0; } }
23 | 
24 |         public void Retake(decimal grade)
25 |         {
26 |             if (grade > 0)
27 |             {
28 |                 Correct = true;
29 |             }
30 |             else
31 |             {
32 |                 Correct = false;
33 |             }
34 |         }
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/test/samples/CS/sample2.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace BethanysPieShop.Models
 7 | {
 8 |     public class Pie
 9 |     {
10 |         public int Id { get; set; }
11 |         public string Name { get; set; }
12 |         public string ShortDescription { get; set; }
13 |         public string LongDescription { get; set; }
14 |         public decimal Price { get; set; }
15 |         public string ImageUrl { get; set; }
16 |         public string ImageThumbnailUrl { get; set; }
17 |         public bool IsPieOfTheWeek { get; set; }
18 | 
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/samples/CS/sample3.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using System.IO;
 4 | 
 5 | namespace LoggingKata
 6 | {
 7 |     class Program
 8 |     {
 9 |         //Why do you think we use ILog?
10 |         static readonly ILog logger = new TacoLogger();
11 |         const string csvPath = "TacoBell-US-AL.csv";
12 | 
13 |         static void Main(string[] args)
14 |         {
15 |             logger.LogInfo("Log initialized");
16 | 
17 |             var lines = File.ReadAllLines(csvPath);
18 | 
19 |             logger.LogInfo($"Lines: {lines[0]}");
20 | 
21 |             var parser = new TacoParser();
22 | 
23 |             var locations = lines.Select(parser.Parse);
24 | 
25 |             // TODO:  Find the two TacoBells in Alabama that are the furthurest from one another.
26 |             // HINT:  You'll need two nested forloops
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/samples/Dockerfiles/.dockerignore:
--------------------------------------------------------------------------------
 1 | # comment
 2 | */temp*
 3 | */*/temp*
 4 | temp?
 5 | 
 6 | *.md
 7 | README-secret.md
 8 | !README*.md
 9 | 
10 | *.md
11 | !README*.md
12 | README-secret.md
13 | 


--------------------------------------------------------------------------------
/test/samples/Dockerfiles/1.Dockerfile:
--------------------------------------------------------------------------------
 1 | # Multiple images example
 2 | #
 3 | # VERSION               0.1
 4 | 
 5 | FROM ubuntu
 6 | RUN echo foo > bar
 7 | # Will output something like ===> 907ad6c2736f
 8 | 
 9 | FROM ubuntu
10 | RUN echo moo > oink
11 | # Will output something like ===> 695d7793cbe4
12 | 
13 | # You'll now have two images, 907ad6c2736f with /bar, and 695d7793cbe4 with
14 | # /oink.
15 | 


--------------------------------------------------------------------------------
/test/samples/Dockerfiles/2.Dockerfile:
--------------------------------------------------------------------------------
 1 | # Firefox over VNC
 2 | #
 3 | # VERSION               0.3
 4 | 
 5 | FROM ubuntu
 6 | 
 7 | # Install vnc, xvfb in order to $create a 'fake' display and firefox
 8 | RUN apt-get update && apt-get install -y x11vnc xvfb firefox
 9 | RUN mkdir ~/.vnc
10 | # Setup a password
11 | RUN x11vnc -storepasswd 1234 ~/.vnc/passwd
12 | # Autostart firefox (might not be the best way, but it does the trick)
13 | RUN bash -c 'echo "firefox" >> /.bashrc'
14 | 
15 | EXPOSE 5900
16 | CMD    ["x11vnc", "-forever", "-usepw", "-create"]
17 | 


--------------------------------------------------------------------------------
/test/samples/Dockerfiles/Dockerfile:
--------------------------------------------------------------------------------
 1 | # escape=`
 2 | # FROM <image> [AS <name>]
 3 | # FROM <image>[:<tag>] [AS <name>]
 4 | # FROM <image>[@<digest>] [AS <name>]
 5 | # FROM golang:alpine
 6 | FROM base:${CODE_VERSION}
 7 | FROM base:$CODE_VERSION
 8 | 
 9 | # ENV <key> <value>
10 | # ENV <key>=<value>
11 | 
12 | RUN apk add --update \
13 |     tzdata bash wget curl git;
14 | 
15 | # Create binary directory, install glide and fresh
16 | RUN mkdir -p $$GOPATH/bin && \
17 |     curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh &&
18 |     # go get github.com/pilu/fresh
19 | 
20 | # define work directory
21 | ADD . /go/src/$PROJECT_FOLDER
22 | WORKDIR /go/src/${PROJECT_FOLDER}  # Still a comment
23 | 
24 | 
25 | # serve the app
26 | CMD dep ensure update && fresh -c runner.conf main.go
27 | 
28 | # LABEL <key>=<value> <key>=<value> <key>=<value> ...
29 | LABEL "com.example.vendor"="ACME Incorporated"
30 | LABEL com.example.label-with-value="foo"
31 | LABEL version="1.0"
32 | LABEL description="This text illustrates \
33 | that label-values can span multiple lines."
34 | 
35 | # Predefined Args:
36 | # HTTP_PROXY
37 | # http_proxy
38 | # HTTPS_PROXY
39 | # https_proxy
40 | # FTP_PROXY
41 | # ftp_proxy
42 | # NO_PROXY
43 | # no_proxy
44 | 


--------------------------------------------------------------------------------
/test/samples/Dockerfiles/go.Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM golang:1.9.2-alpine3.6 AS build
 2 | 
 3 | # Install tools required to build the project
 4 | # We need to run `docker build --no-cache .` to update those dependencies
 5 | RUN apk add --no-cache git
 6 | RUN go get github.com/golang/dep/cmd/dep
 7 | 
 8 | # Gopkg.toml and Gopkg.lock lists project dependencies
 9 | # These layers are only re-built when Gopkg files are updated
10 | COPY Gopkg.lock Gopkg.toml /go/src/project/
11 | WORKDIR /go/src/project/
12 | # Install library dependencies
13 | RUN dep ensure -vendor-only
14 | 
15 | # Copy all project and build it
16 | # This layer is rebuilt when ever a file has changed in the project directory
17 | COPY . /go/src/project/
18 | RUN go build -o /bin/project
19 | 
20 | # This results in a single layer image
21 | FROM scratch
22 | COPY --from=build /bin/project /bin/project
23 | ENTRYPOINT ["/bin/project"]
24 | CMD ["--help"]
25 | 


--------------------------------------------------------------------------------
/test/samples/JS/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |     "extends": ["eslint:recommended", "google"],
 3 |     "parserOptions": {
 4 |         "ecmaVersion": 6,
 5 |         "sourceType": "module"
 6 |     },
 7 |     "env": {
 8 |         "browser": true
 9 |     },
10 |     "plugins": [
11 |         "html"
12 |     ],
13 |     "rules": {
14 |         "brace-style": "off",
15 |         "new-cap": ["error", { "capIsNewExceptions": ["Polymer"] }],
16 |         "no-var": "off",
17 |         "require-jsdoc": "off"
18 |     },
19 |     "globals": {
20 |         "Polymer": true
21 |     }
22 | };
23 | 


--------------------------------------------------------------------------------
/test/samples/JS/MyElement.js:
--------------------------------------------------------------------------------
 1 | import {PolymerElement} from '@polymer/polymer/polymer-element.js';
 2 | 
 3 | class MyComponent extends PolymerElement {
 4 |   constructor() {
 5 |     super();
 6 |   }
 7 | 
 8 |   static get template() {
 9 |     return `<div> I'm the Component! </div>`;
10 |   }
11 | 
12 |   static get is() {return 'my-component';}
13 | }
14 | 
15 | customElements.define('my-component', MyComponent);
16 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/build-toc.ts:
--------------------------------------------------------------------------------
 1 | import { deepMap } from "react-children-utilities"
 2 | 
 3 | type TocItem = any
 4 | 
 5 | /**
 6 |  * @see [React Children Utilities - `deepMap()`](https://fernandopasik.com/react-children-utilities/deep-map)
 7 |  */
 8 | export const buildToc = <T = any,>(children: T): [children: T, toc: TocItem[]] => {
 9 |     return [children, []]
10 | }
11 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/calculator.ts:
--------------------------------------------------------------------------------
 1 | window.onload = function () {
 2 |     var calc = new Calculator('X','Y','Output');
 3 | };
 4 | 
 5 | class Calculator {
 6 |     private x : HTMLInputElement;
 7 |     private y : HTMLInputElement;
 8 |     private output : HTMLSpanElement;
 9 | 
10 |     constructor(xId: string, yId: string, outputId: string) {
11 |         this.x = <HTMLInputElement>document.getElementById(xId);
12 |         this.y = <HTMLInputElement>document.getElementById(yId);
13 |         this.output = <HTMLSpanElement>document.getElementById(outputId);
14 |         this.wireEvents();
15 |     }
16 | 
17 |     wireEvents() {
18 |         document.getElementById('Add').addEventListener('click',
19 |             event => {
20 |                 this.output.innerHTML = this.add(parseInt(this.x.value), parseInt(this.y.value)).toString()
21 |             });
22 |         document.getElementById('Subtract').addEventListener('click',
23 |             event => {
24 |                 this.output.innerHTML = this.subtract(parseInt(this.x.value), parseInt(this.y.value)).toString()
25 |             });
26 |     }
27 | 
28 |     add(x: number, y : number) {
29 |         return x + y;
30 |     }
31 | 
32 |     subtract(x : number, y: number) {
33 |         return x - y;
34 |     }
35 | }
36 | 
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/case.ts:
--------------------------------------------------------------------------------
 1 | function handleRoute() {
 2 |     switch (true) {
 3 |         case url.endsWith("/api/v1/auth/login") && method === "POST":
 4 |             return authenticate()
 5 |         case url.endsWith("/users") && method === "GET":
 6 |             return getUsers()
 7 |         default:
 8 |             // pass through any requests not handled above
 9 |             return next.handle(request)
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/cyph.helper.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import {parse, stringify} from '../../../util/serialization';
 3 | import {potassiumUtil} from '../potassium-util';
 4 | 
 5 | 
 6 | /**
 7 |  * Wrapper for SubtleCrypto key import and export APIs.
 8 |  */
 9 | export class ImportHelper {
10 | 	/** Converts CryptoKey object into JWK byte array. */
11 | 	public async exportJWK (
12 | 		cryptoKey: CryptoKey,
13 | 		algorithmName: string
14 | 	) : Promise<Uint8Array> {
15 | 		return potassiumUtil.fromString(
16 | 			stringify(
17 | 				await (<any> crypto.subtle).exportKey(
18 | 					'jwk',
19 | 					cryptoKey,
20 | 					algorithmName
21 | 				)
22 | 			)
23 | 		);
24 | 	}
25 | 
26 | 	/** Converts CryptoKey object into raw byte array. */
27 | 	public async exportRawKey (
28 | 		cryptoKey: CryptoKey,
29 | 		algorithmName: string
30 | 	) : Promise<Uint8Array> {
31 | 		return (<any> crypto.subtle).exportKey(
32 | 			'raw',
33 | 			cryptoKey,
34 | 			algorithmName
35 | 		);
36 | 	}
37 | 
38 | 	/** Converts JWK byte array into CryptoKey object. */
39 | 	public async importJWK (
40 | 		key: Uint8Array,
41 | 		algorithm: any,
42 | 		purpose: string
43 | 	) : Promise<CryptoKey> {
44 | 		return crypto.subtle.importKey(
45 | 			'jwk',
46 | 			parse<JsonWebKey>(
47 | 				potassiumUtil.toString(
48 | 					potassiumUtil.toBytes(key, 0, key.indexOf(0))
49 | 				)
50 | 			),
51 | 			algorithm,
52 | 			false,
53 | 			[purpose]
54 | 		);
55 | 	}
56 | 
57 | 	/** Converts raw byte array into CryptoKey object. */
58 | 	public async importRawKey (
59 | 		key: Uint8Array,
60 | 		algorithm: any,
61 | 		purpose: string
62 | 	) : Promise<CryptoKey> {
63 | 		return crypto.subtle.importKey(
64 | 			'raw',
65 | 			new Uint8Array(key).buffer,
66 | 			algorithm,
67 | 			false,
68 | 			[purpose]
69 | 		);
70 | 	}
71 | 
72 | 	constructor () {}
73 | }
74 | 
75 | /** @see ImportHelper */
76 | export const importHelper	= new ImportHelper();
77 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/editable-article-resolver.service.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import { Injectable } from '@angular/core';
 3 | import { ActivatedRouteSnapshot, Resolve, Router, RouterStateSnapshot } from '@angular/router';
 4 | import { Observable } from 'rxjs/Observable';
 5 | 
 6 | import { Article, ArticlesService, UserService } from '../shared';
 7 | import { map, catchError } from 'rxjs/operators';
 8 | 
 9 | @Injectable()
10 | export class EditableArticleResolver implements Resolve<Article> {
11 |   constructor(
12 |     private articlesService: ArticlesService,
13 |     private router: Router,
14 |     private userService: UserService
15 |   ) { }
16 | 
17 |   resolve(
18 |     route: ActivatedRouteSnapshot,
19 |     state: RouterStateSnapshot
20 |   ): Observable<any> {
21 | 
22 |     return this.articlesService.get(route.params['slug'])
23 |       .pipe(
24 |         map(
25 |           article => {
26 |             if (this.userService.getCurrentUser().username === article.author.username) {
27 |               return article;
28 |             } else {
29 |               this.router.navigateByUrl('/');
30 |             }
31 |           }
32 |         ),
33 |         catchError((err) => this.router.navigateByUrl('/'))
34 |       );
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/gov.parse.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import { DefaultUrlSerializer, UrlSerializer, UrlTree } from '@angular/router';
 3 | 
 4 | export class CustomUrlSerializer implements UrlSerializer {
 5 | 
 6 |     private _defaultUrlSerializer: DefaultUrlSerializer = new DefaultUrlSerializer();
 7 | 
 8 |     parse(url: string): UrlTree {
 9 | 
10 |         /*
11 |             We, counter-intuitively, replace parentheses with their
12 |             escaped equivalent because the DefaultUrlSerializer
13 |             incorrectly stops parsing when it hits a parentheses.
14 |             It does however correctly parse urls with
15 |             escaped parentheses.
16 |         */
17 |         url = url.replace(/\(/g, '%28').replace(/\)/g, '%29');
18 | 
19 |         return this._defaultUrlSerializer.parse(url);
20 | 
21 |     }
22 | 
23 |     serialize(tree: UrlTree): string {
24 | 
25 |         return this._defaultUrlSerializer.serialize(tree).replace(/\(/g, '%28').replace(/\)/g, '%29');
26 | 
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/home.component.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | import { Component, OnInit } from '@angular/core';
 3 | import { Router } from '@angular/router';
 4 | 
 5 | import { ArticleListConfig, TagsService, UserService } from '../shared';
 6 | 
 7 | @Component({
 8 |   selector: 'app-home-page',
 9 |   templateUrl: './home.component.html',
10 |   styleUrls: ['./home.component.css']
11 | })
12 | export class HomeComponent implements OnInit {
13 |   constructor(
14 |     private router: Router,
15 |     private tagsService: TagsService,
16 |     private userService: UserService
17 |   ) {}
18 | 
19 |   isAuthenticated: boolean;
20 |   listConfig: ArticleListConfig = {
21 |     type: 'all',
22 |     filters: {}
23 |   };
24 |   tags: Array<string> = [];
25 |   tagsLoaded = false;
26 | 
27 |   ngOnInit() {
28 |     this.userService.isAuthenticated.subscribe(
29 |       (authenticated) => {
30 |         this.isAuthenticated = authenticated;
31 | 
32 |         // set the article list accordingly
33 |         if (authenticated) {
34 |           this.setListTo('feed');
35 |         } else {
36 |           this.setListTo('all');
37 |         }
38 |       }
39 |     );
40 | 
41 |     this.tagsService.getAll()
42 |     .subscribe(tags => {
43 |       this.tags = tags;
44 |       this.tagsLoaded = true;
45 |     });
46 |   }
47 | 
48 |   setListTo(type: string = '', filters: Object = {}) {
49 |     // If feed is requested but user is not authenticated, redirect to login
50 |     if (type === 'feed' && !this.isAuthenticated) {
51 |       this.router.navigateByUrl('/login');
52 |       return;
53 |     }
54 | 
55 |     // Otherwise, set the list object
56 |     this.listConfig = {type: type, filters: filters};
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/test/samples/JS/TS/server.ts:
--------------------------------------------------------------------------------
 1 | /// <reference path="node.d.ts" />
 2 | 
 3 | import http = require('http');
 4 | var server = http.createServer(function (req, res) {
 5 |     res.writeHead(200);
 6 |     res.end('Hello from Node.js');
 7 | });
 8 | server?.listen(1500);
 9 | console.log('Listening...');
10 | 


--------------------------------------------------------------------------------
/test/samples/JS/as.js:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import Header from './components/layout/Header';
 3 | import Sidebar from './components/layout/Sidebar';
 4 | import { HashRouter as Router, Route } from 'react-router-dom';
 5 | import { Home } from './components/Home';
 6 | 
 7 | const App = () => {
 8 | 
 9 |   return (
10 |     <Router>
11 |       <div>
12 |         <Header />
13 |         <Sidebar />
14 |         <div className='rightContentContainer'>
15 |           <Route path='/' component={Home}/>
16 |         </div>
17 |       </div>
18 |     </Router>
19 |   );
20 | };
21 | 
22 | 
23 | export default App;
24 | 


--------------------------------------------------------------------------------
/test/samples/JS/case.js:
--------------------------------------------------------------------------------
 1 | function handleRoute() {
 2 |     switch (true) {
 3 |         case url.endsWith("/api/v1/auth/login") && method === "POST":
 4 |             return authenticate()
 5 |         case url.endsWith("/users") && method === "GET":
 6 |             return getUsers()
 7 |         default:
 8 |             // pass through any requests not handled above
 9 |             return next.handle(request)
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/HelloWorld.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="hello">
 3 | 
 4 |   </div>
 5 | </template>
 6 | 
 7 | <script lang="ts">
 8 | import { Component, Prop, Vue } from 'vue-property-decorator';
 9 | 
10 | @Component
11 | export default class HelloWorld extends Vue {
12 |   @Prop() private msg!: string;
13 | }
14 | </script>
15 | 
16 | <script>
17 | import { Component, Prop, Vue } from 'vue-property-decorator';
18 | 
19 | @Component
20 | export default class HelloWorld extends Vue {
21 |   @Prop() msg
22 | }
23 | </script>
24 | 
25 | <style scoped lang="scss">
26 | h3 {
27 |   margin: 40px 0 0;
28 | }
29 | ul {
30 |   list-style-type: none;
31 |   padding: 0;
32 | }
33 | li {
34 |   display: inline-block;
35 |   margin: 0 10px;
36 | }
37 | a {
38 |   color: #42b983;
39 | }
40 | </style>
41 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/SObject.js:
--------------------------------------------------------------------------------
 1 | import {
 2 |     Model,
 3 |     Column,
 4 |     Table,
 5 |     CreatedAt,
 6 |     UpdatedAt,
 7 | } from "sequelize-typescript"
 8 | 
 9 | const some = null;
10 | @Table({
11 |     tableName: "SObjects",
12 |     any: some,
13 | })
14 | export class {
15 |     @CreatedAt
16 |     @Column
17 |     createdAt() {
18 |         return null
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/SObject.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |     Model,
 3 |     Column,
 4 |     Table,
 5 |     CreatedAt,
 6 |     UpdatedAt,
 7 | } from "sequelize-typescript"
 8 | 
 9 | const some = null;
10 | @Table({
11 |     tableName: "SObjects",
12 |     any: some,
13 | })
14 | export class SObject extends Model<SObject> {
15 | 
16 |     @Column
17 |     name!: string;
18 | 
19 |     @Column
20 |     custom: boolean;
21 | 
22 |     @Column
23 |     queryable: boolean;
24 | 
25 |     @Column
26 |     alias?: string;
27 | 
28 |     @Column
29 |     description: string;
30 | 
31 |     @Column
32 |     salesforce_count: number;
33 | 
34 |     @CreatedAt
35 |     @Column
36 |     createdAt!: Date;
37 | 
38 |     @UpdatedAt
39 |     @Column
40 |     updatedAt!: Date;
41 | }
42 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/app.module.js:
--------------------------------------------------------------------------------
 1 | import { BrowserModule } from '@angular/platform-browser'
 2 | import { NgModule } from '@angular/core'
 3 | import { HttpClientModule } from '@angular/common/http'
 4 | 
 5 | import { AppRoutingModule } from './app-routing.module';
 6 | import { AppComponent } from './app.component';
 7 | 
 8 | @NgModule({
 9 |     declarations: [
10 |         AppComponent
11 |     ],
12 |     imports: [
13 |         BrowserModule,
14 |         AppRoutingModule,
15 |         HttpClientModule,
16 |     ],
17 |     providers: [],
18 |     bootstrap: [AppComponent]
19 | })
20 | export class AppModule { }
21 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/app.module.ts:
--------------------------------------------------------------------------------
 1 | import { BrowserModule } from '@angular/platform-browser'
 2 | import { NgModule } from '@angular/core'
 3 | import { HttpClientModule } from '@angular/common/http'
 4 | 
 5 | import { AppRoutingModule } from './app-routing.module';
 6 | import { AppComponent } from './app.component';
 7 | 
 8 | @NgModule({
 9 |     declarations: [
10 |         AppComponent
11 |     ],
12 |     imports: [
13 |         BrowserModule,
14 |         AppRoutingModule,
15 |         HttpClientModule,
16 |     ],
17 |     providers: [],
18 |     bootstrap: [AppComponent]
19 | })
20 | export class AppModule { }
21 | 


--------------------------------------------------------------------------------
/test/samples/JS/decorators/decorators.ts:
--------------------------------------------------------------------------------
 1 | import { suite, test } from '@testdeck/mocha';
 2 | 
 3 | @suite
 4 | class Suite {
 5 | 
 6 |   @test('a custom name for the test')
 7 |   test() {}
 8 | 
 9 |   @test 'alternate naming'() { }
10 | }
11 | 


--------------------------------------------------------------------------------
/test/samples/JS/destruct.js:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | 
 3 | const VideoListItem = ({video}) => {
 4 |   const imageUrl = video?.snippet.thumbnails.default.url;
 5 | 
 6 |   return (
 7 |     <li className="list-group-item">
 8 |       <div className="video-list media">
 9 |         <div className="media-left">
10 |           <img className="media-object" src={imageUrl}/>
11 |         </div>
12 | 
13 |         <div className="media-body">
14 |           <div className="media-heading">
15 |             {video.snippet.title}
16 |           </div>
17 |         </div>
18 |       </div>
19 |     </li>
20 |   );
21 | }
22 | 
23 | export default VideoListItem;
24 | 


--------------------------------------------------------------------------------
/test/samples/JS/gulpfile.js:
--------------------------------------------------------------------------------
 1 | const gulp  = require('gulp');
 2 | const merge = require('gulp-merge-json');
 3 | const json5 = require('gulp-json5-to-json');
 4 | 
 5 | let codeFolder = () => {
 6 |   if (process.platform === 'darwin') {
 7 |   } else if (process.platform === 'linux') {
 8 |   } else if (process?.platform === 'win32') {
 9 |     return "FIXME: code settings folder on windows?"
10 |   }
11 |   switch (process.platform) {
12 |     case 'darwin':
13 |       return `${process.env.HOME}/Library/Application Support/Code - Insiders/User`;
14 |       break;
15 |     case 'linux':
16 |       return `${process.env.HOME}/.config/Code/User`;
17 |       break;
18 | 
19 |     default:
20 |       return "";
21 |       break;
22 |   }
23 | }
24 | 
25 | gulp.task('default', () => { });
26 | 
27 | gulp.task('code:compile-settings', () =>
28 |   gulp.src('./editors/vscode/settings/*.json5')
29 |     .pipe(merge({
30 |       fileName: "settings.json",
31 |       json5: true,
32 |     }))
33 |     .pipe(json5({beautify:true}))
34 |     .pipe(gulp.dest(codeFolder()))
35 | );
36 | 


--------------------------------------------------------------------------------
/test/samples/JS/imports.js:
--------------------------------------------------------------------------------
1 | import { React } from "react";
2 | import { ReactDOM } from 'react-dom';
3 | import App from './components.app';
4 | 
5 | ReactDOM.render(
6 |     <App/>,
7 |     document.getElementById('app'),
8 | );
9 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/Clock.jsx:
--------------------------------------------------------------------------------
 1 | export class Clock extends React.Component {
 2 |     constructor(props) {
 3 |       super(props);
 4 |       this.state = {time: this.props.time};
 5 |       this._update = this._updateTime.bind(this);
 6 |     }
 7 | 
 8 |     render() {
 9 |       var time = this._formatTime(this.state.time);
10 |       return (
11 |         <h1>{ time.hours } : { time.minutes } : { time.seconds }</h1>
12 |       );
13 |     }
14 | 
15 |     componentDidMount() {
16 |       this._interval = setInterval(this._update, 1000);
17 |     }
18 | 
19 |     componentWillUnmount() {
20 |       clearInterval(this._interval);
21 |     }
22 | 
23 |     _formatTime(time) {
24 |       var [ hours, minutes, seconds ] = [
25 |         time.getHours(),
26 |         time.getMinutes(),
27 |         time.getSeconds(),
28 |       ].map(num => num < 10 ? '0' + num : num);
29 | 
30 |       return {hours, minutes, seconds};
31 |     }
32 | 
33 |     _updateTime() {
34 |       this.setState({time: new Date(this.state.time.getTime() + 1000)});
35 |     }
36 |   }
37 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/folder.js:
--------------------------------------------------------------------------------
 1 | // import React, { Component } from 'react';
 2 | import { Component } from 'react';
 3 | 
 4 | function interp(word) {
 5 |     return `Your word is ${word}.`
 6 | }
 7 | 
 8 | export class Folder extends Component {
 9 | 
10 |   constructor(props) {
11 |     super(props);
12 | 
13 |     this.state = {
14 |       data: props.data,
15 |     };
16 |   }
17 | 
18 |   render() {
19 |     return (
20 |       <div className="folder">
21 |         <div className="file-icon"></div>
22 |         <span className="file-name"> {this.props.name} </span>
23 |         <span className="file-info"> {this.props.info} </span>
24 |       </div>
25 |     );
26 |   }
27 | 
28 | };
29 | 
30 | import React from 'react';
31 | 
32 | const Folder  = (props) => {
33 |   const { name, info } = props;
34 |   return (
35 |     <div className="folder">
36 |         <div className="file-icon"></div>
37 |         <span className="file-name"> {name} </span>
38 |         <span className="file-info"> {info} </span>
39 |     </div>
40 |   );
41 | };
42 | 
43 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/folder.jsx:
--------------------------------------------------------------------------------
 1 | // import React, { Component } from 'react';
 2 | import { Component } from 'react';
 3 | 
 4 | export class Folder extends Component {
 5 | 
 6 |   constructor(props) {
 7 |     super(props);
 8 | 
 9 |     this.state = {
10 |       data: props.data,
11 |     };
12 |   }
13 | 
14 |   render() {
15 |     return (
16 |       <div className="folder">
17 |         <div className="file-icon"></div>
18 |         <span className="file-name"> {this.props.name} </span>
19 |         <span className="file-info"> {this.props.info} </span>
20 |       </div>
21 |     );
22 |   }
23 | 
24 | };
25 | 
26 | import React from 'react';
27 | 
28 | const Folder  = (props) => {
29 |   const { name, info } = props;
30 |   return (
31 |     <div className="folder">
32 |         <div className="file-icon"></div>
33 |         <span className="file-name"> {name} </span>
34 |         <span className="file-info"> {info} </span>
35 |     </div>
36 |   );
37 | };
38 | 
39 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/render-props.jsx:
--------------------------------------------------------------------------------
1 | <DataProvider render={(data) => (<h1>Hello {data.target}</h1>) }/>
2 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/touchy-tags/01.js:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import { AutoSizer, List, InfiniteLoader, Table, Column } from "react-virtualized";
 3 | import { Modal } from 'react-bootstrap';
 4 | 
 5 | 
 6 | export default ({ products, setSelectedProduct }) => {
 7 | 
 8 |     const rowRenderer = ({ key, index, style }) => {
 9 |         let product = products[index];
10 |         return (
11 |             <Product key={key} style={style} {...product} />
12 |         );
13 |     };
14 | 
15 | 
16 |     return (
17 |         <AutoSizer disableHeight>
18 |             {({ width }) => (
19 |                 <Table>
20 |                     <Column
21 |                         label='Edit'
22 |                         className="col-sm-1"
23 |                         cellDataGetter={({ rowData: { id } }) => id}
24 |                         cellRenderer={({ cellData, rowData }) => <button onClick={() => setSelectedProduct(rowData)} className="btn btn-xs btn-danger">Edit</button>}
25 |                         width={10}
26 |                     />
27 |                 </Table>
28 |             )}
29 |         </AutoSizer>
30 |     );
31 | }
32 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/touchy-tags/Toggle.js:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | 
 3 | export class Toggle extends React.Component {
 4 |   state = {
 5 |     on: false,
 6 |   }
 7 | 
 8 |   toggle = () => {
 9 |     this.setState({
10 |       on: !this.state.on
11 |     });
12 |   }
13 |   render() {
14 |     return (
15 |       <div>
16 |         {this.state.on && <h1>Toggle Me!</h1>}
17 |         <button onClick={this.toggle}>Show/Hide</button>
18 |       </div>
19 |     )
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/test/samples/JS/jsx/touchy-tags/bind.js:
--------------------------------------------------------------------------------
 1 | import React, { Component } from 'react';
 2 | import { connect } from 'react-redux';
 3 | import { bindActionCreators } from 'redux';
 4 | 
 5 | // bindActionCreators, connect;
 6 | 
 7 | class Thinc extends Component {
 8 |   render() {
 9 |     let {name, activeTab, classes} = this.props;
10 | 
11 |     if (name === activeTab) {
12 |       classes += ' active';
13 |     }
14 | 
15 |     return (
16 |       <div className={classes} role="tabpanel">
17 |         <div className="tab-content">
18 |           <div className="row">
19 |             {this.props.children}
20 |           </div>
21 |         </div>
22 |       </div>
23 |     );
24 |   }
25 | }
26 | 
27 | export default Thinc;
28 | 


--------------------------------------------------------------------------------
/test/samples/JS/regex.js:
--------------------------------------------------------------------------------
 1 | module.exports = [
 2 |     // {
 3 |     //     "scope": [
 4 |     //     ],
 5 |     //     "settings": { "foreground": "#9cdcfe", },
 6 |     // },
 7 |     {
 8 |         "scope": [
 9 |             "keyword.operator.quantifier.regexp",
10 |             "keyword.operator.quantifier.regexp.js",
11 |         ],
12 |         "settings": { "foreground": "#b5cea8", },
13 |     },
14 |     {
15 |         "scope": [
16 |             "string.regexp",
17 |             "constant.regexp",
18 |         ],
19 |         "settings": { "foreground": "#d16969", },
20 |     },
21 |     {
22 |         "scope": [
23 |             "constant.character.escape.backslash.regexp",
24 |         ],
25 |         "settings": { "foreground": "#d7ba7d", },
26 |     },
27 |     {
28 |         "scope": [
29 |             "constant.other.character-class.regexp",
30 |         ],
31 |         "settings": { "foreground": "#4ec9b0", },
32 |     },
33 |     {
34 |         "scope": [
35 |             "keyword.control.anchor.regexp",
36 |             "constant.other.character-class.regexp",
37 |         ],
38 |         "settings": { "foreground": "#569cd6", },
39 |     },
40 |     {
41 |         "scope": [
42 |             "punctuation.definition.group.regexp",
43 |             "punctuation.definition.character-class.regexp",
44 |         ],
45 |         "settings": { "foreground": "#d4d4d4", },
46 |     },
47 | ];
48 | 


--------------------------------------------------------------------------------
/test/samples/JS/sample.coffee:
--------------------------------------------------------------------------------
 1 | fibonacci = ->
 2 |     [previous, current] = [1, 1]
 3 |         loop
 4 |             [previous, current] = [current, previous + current]
 5 |         yield current
 6 |     return
 7 | 
 8 | getFibonacciNumbers = (length) ->
 9 |     results = [1]
10 |     for n from fibonacci()
11 |         results.push n
12 |         break if results.length is length
13 |     results
14 | 
15 | class Hello extends World
16 |     constructor: (name) ->
17 |         @label = """
18 |             Hello #{name}!
19 |         """
20 | 
21 |     log: ->
22 |         console.log(@label)
23 | 
24 | switch day
25 |     when "Mon" then go work
26 |     when "Tue" then go relax
27 |     when "Thu" then go iceFishing
28 |     when "Fri", "Sat"
29 |         if day is bingoDay
30 |             go bingo
31 |             go dancing
32 |     when "Sun" then go church
33 |     else go work
34 | 
35 | date = if friday then sue else jill
36 | 


--------------------------------------------------------------------------------
/test/samples/JS/sample.js:
--------------------------------------------------------------------------------
 1 | // Normal Comments
 2 | /* Line Comments */
 3 | /**
 4 |  * Doc Comments
 5 |  * param:
 6 |  * @param {*function} g Lorem Ipsum Explain Yadda Yadda
 7 |  */
 8 | function coroutine(g) {
 9 |     let it = g();
10 |     return function () {
11 |         // FIXME: `punctuation.accessor.optional.js`
12 |         return it?.next().apply(it, arguments);
13 |     };
14 | }
15 | 
16 | var step = coroutine(function* () {
17 |     var x = 1 + (yield);
18 |     var y = 1 + (yield);
19 |     yield(x + y);
20 | });
21 | 
22 | 
23 | /*
24 |  * Block Comments
25 |  */
26 | step();
27 | step(10);
28 | console.log(
29 |     `Meaning of life: ${step(30).value}.`
30 | );
31 | 
32 | const pattern = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
33 | 


--------------------------------------------------------------------------------
/test/samples/JS/tsx/About.tsx:
--------------------------------------------------------------------------------
 1 | import * as React from "react";
 2 | import { Component } from "react";
 3 | 
 4 | export default class About extends Component<IAboutProps,IAboutState> {
 5 |     constructor(props: IAboutProps) {
 6 | 		super(props);
 7 | 		console.log("this is not a useless constructor");
 8 | 	}
 9 |     render() {
10 |         return(
11 |             <div className="container text-center">
12 |                 <h1>About</h1>
13 |             </div>
14 |         )
15 |     }
16 | }
17 | 
18 | interface IAboutProps {}
19 | 
20 | interface IAboutState {}
21 | 


--------------------------------------------------------------------------------
/test/samples/JS/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path');
 2 | const htmlWebpackPlugin = require('html-webpack-plugin');
 3 | 
 4 | module.exports = {
 5 |   entry: path.join(__dirname, 'src', 'index.js'),
 6 |   output: {
 7 |     path: path.join(__dirname, 'dist'),
 8 |     filename: 'index.bundle.js',
 9 |   },
10 |   module: {
11 |     rules: [
12 |       {
13 |         test: /\.js$/,
14 |         exclude: /node_modules/,
15 |         use: {
16 |           loader: 'babel-loader',
17 |         },
18 |       },
19 |     ],
20 |   },
21 |   plugins: [
22 |     new htmlWebpackPlugin({
23 |       template: path.join(__dirname, 'src', 'index.html'),
24 |     }),
25 |   ],
26 | };
27 | 


--------------------------------------------------------------------------------
/test/samples/Misc/etc/Gopkg.lock:
--------------------------------------------------------------------------------
 1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 2 | 
 3 | 
 4 | [[projects]]
 5 |   name = "github.com/google/go-github"
 6 |   packages = ["github"]
 7 |   revision = "e48060a28fac52d0f1cb758bc8b87c07bac4a87d"
 8 |   version = "v15.0.0"
 9 | 
10 | [[projects]]
11 |   branch = "master"
12 |   name = "github.com/google/go-querystring"
13 |   packages = ["query"]
14 |   revision = "53e6ce116135b80d037921a7fdd5138cf32d7a8a"
15 | 
16 | [[projects]]
17 |   branch = "master"
18 |   name = "golang.org/x/crypto"
19 |   packages = ["ssh/terminal"]
20 |   revision = "88942b9c40a4c9d203b82b3731787b672d6e809b"
21 | 
22 | [[projects]]
23 |   branch = "master"
24 |   name = "golang.org/x/sys"
25 |   packages = [
26 |     "unix",
27 |     "windows"
28 |   ]
29 |   revision = "13d03a9a82fba647c21a0ef8fba44a795d0f0835"
30 | 
31 | [solve-meta]
32 |   analyzer-name = "dep"
33 |   analyzer-version = 1
34 |   inputs-digest = "1fb20ff16bae585a8c29e5a8bbe0f7dbffbca7dd8273e3b780ebb4b4a333dcbb"
35 |   solver-name = "gps-cdcl"
36 |   solver-version = 1
37 | 


--------------------------------------------------------------------------------
/test/samples/Misc/etc/default.conf:
--------------------------------------------------------------------------------
 1 | upstream client {
 2 |   server client:3000;
 3 | }
 4 | 
 5 | upstream api {
 6 |   server api:3000;
 7 | }
 8 | 
 9 | server {
10 |   listen 80;
11 | 
12 |   location / {
13 |     proxy_pass http://client;
14 |   }
15 | 
16 |   location /api {
17 |     reqrite /api/(.*) /$1 break;
18 |     proxy_pass http://api;
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/samples/Misc/etc/example.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LoggingKata", "LoggingKata\LoggingKata.csproj", "{7ADECD8F-C2B8-437F-9BCD-80CA280CB46F}"
 5 | EndProject
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LoggingKata.Test", "LoggingKata.Test\LoggingKata.Test.csproj", "{D12AA5B6-2F62-4BF2-8080-0C276FC1177C}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{7ADECD8F-C2B8-437F-9BCD-80CA280CB46F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{7ADECD8F-C2B8-437F-9BCD-80CA280CB46F}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{7ADECD8F-C2B8-437F-9BCD-80CA280CB46F}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{7ADECD8F-C2B8-437F-9BCD-80CA280CB46F}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 		{D12AA5B6-2F62-4BF2-8080-0C276FC1177C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
19 | 		{D12AA5B6-2F62-4BF2-8080-0C276FC1177C}.Debug|Any CPU.Build.0 = Debug|Any CPU
20 | 		{D12AA5B6-2F62-4BF2-8080-0C276FC1177C}.Release|Any CPU.ActiveCfg = Release|Any CPU
21 | 		{D12AA5B6-2F62-4BF2-8080-0C276FC1177C}.Release|Any CPU.Build.0 = Release|Any CPU
22 | 	EndGlobalSection
23 | EndGlobal
24 | 


--------------------------------------------------------------------------------
/test/samples/Misc/etc/todo.txt:
--------------------------------------------------------------------------------
1 | x (A) 2018-03-17 Scaffold out the basic +project.
2 | 
3 | (A) 2018-03-17 Figure out how to disable language support for normal ".txt" files. +vscode-todotxt  @TodoTxt.
4 | 2018-03-17 Figure out how to disable language +support for normal '.txt' files. +vscode-todotxt.
5 | (B) 2018-03-17 Figure out what the deal is with the RegExs used in language definitions. @TodoTxt
6 | (C) 2018-03-17 Define miscellaneous tags. ex:this. due:2018-03-17.
7 | (C) 2018-03-17 Handle complex tags. ex:something.like.this ex:or#like#this() okay?
8 | (D) 2018-03-17 Figure out how to disable language +support for normal `.txt` files. +vscode-todotxt.
9 | 


--------------------------------------------------------------------------------
/test/samples/Misc/restructuredtext.rst:
--------------------------------------------------------------------------------
 1 | 
 2 | $ easy_install docutils
 3 | 
 4 | $ pip install docutils
 5 | 
 6 | .. Lines starting with two dots are special commands. But if no command can be found, the line is considered as a comment
 7 | 
 8 | =========================================================
 9 | Main titles are written using equals signs over and under
10 | =========================================================
11 | 
12 | Note that there must be as many equals signs as title characters.
13 | 
14 | Title are underlined with equals signs too
15 | ==========================================
16 | 
17 | Subtitles with dashes
18 | ---------------------
19 | 
20 | And sub-subtitles with tildes
21 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
22 | 
23 | You can  put text in *italic* or in **bold**, you can "mark" text as code with double backquote ``: ``print()``.
24 | 
25 | Lists are as simple as in Markdown:
26 | 
27 | - First item
28 | - Second item
29 |     - Sub item
30 | 
31 | or
32 | 
33 | * First item
34 | * Second item
35 |     * Sub item
36 | 
37 | Tables are really easy to write:
38 | 
39 | =========== ========
40 | Country     Capital
41 | =========== ========
42 | France      Paris
43 | Japan       Tokyo
44 | =========== ========
45 | 
46 | More complex tabless can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
47 | 
48 | There are multiple ways to make links:
49 | 
50 | - By adding an underscore after a word : Github_ and by adding the target URL after the text (this way has the advantage to not insert unnecessary URLs inside readable text).
51 | - By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link)
52 | - By making a more Markdown-like link: `Github <https://github.com/>`_ .
53 | 
54 | .. _Github https://github.com/
55 | 
56 | 
57 | $ rst2html myfile.rst output.html
58 | 
59 | 


--------------------------------------------------------------------------------
/test/samples/clang/cli.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLI_H
 2 | #define CLI_H
 3 | 
 4 | #include "common.h"
 5 | 
 6 | #ifndef CLI_NAME
 7 | #define CLI_NAME "fsevent_wa tch"
 8 | #endif /* CLI_NAME */
 9 | 
10 | struct cli_info {
11 |   UInt64 since_when_arg;
12 |   double latency_arg;
13 |   bool no_defer_flag;
14 |   bool watch_root_flag;
15 |   bool ignore_self_flag;
16 |   bool file_events_flag;
17 |   bool mark_self_flag;
18 |   int format_arg;
19 | 
20 |   char** inputs;
21 |   unsigned inputs_num;
22 | };
23 | 
24 | extern const char* cli_info_purpose;
25 | extern const char* cli_info_usage;
26 | extern const char* cli_info_help[];
27 | 
28 | void cli_print_help(void);
29 | void cli_print_version(void);
30 | 
31 | int cli_parser (int argc, const char** argv, struct cli_info* args_info);
32 | void cli_parser_init (struct cli_info* args_info);
33 | void cli_parser_free (struct cli_info* args_info);
34 | 
35 | 
36 | #endif /* CLI_H */
37 | 


--------------------------------------------------------------------------------
/test/samples/clang/count.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | // count digits, whitespace, and others
 4 | main()
 5 | {
 6 |     int c, i, nwhite, nother;
 7 |     int ndigit[10];
 8 | 
 9 |     nwhite = nother = 0;
10 | 
11 |     for (i = 0; i < 10; ++i)
12 |     {
13 |         ndigit[i] = 0;
14 |     }
15 | 
16 |     while ((c = getchar()) != EOF)
17 |     {
18 |         if (c >= '0' && c <= '9')
19 |         {
20 |             ++ndigit[c-'O'];
21 |         }
22 |         else if (c == ' ' ||  c == '\n' || c == '\t')
23 |         {
24 |             ++nwhite;
25 |         }
26 |         else
27 |         {
28 |             ++nother;
29 |         }
30 |     }
31 | 
32 |     printf("digits =");
33 |     for (i = 0; i < 10; ++i)
34 |     {
35 |         printf(" %d", ndigit[i]);
36 |     }
37 |     printf(", white space = %d, other = %d\n", nwhite, nother);
38 | }
39 | 


--------------------------------------------------------------------------------
/test/samples/clang/hello-world.c:
--------------------------------------------------------------------------------
1 | #include <stdio.h>
2 | 
3 | int main()
4 | {
5 |     printf("hello, world\n");
6 | }
7 | 


--------------------------------------------------------------------------------
/test/samples/clang/hello.c:
--------------------------------------------------------------------------------
 1 | #include <fcntl.h>
 2 | 
 3 | void main()
 4 | {
 5 |   int fd;
 6 |   fd = open("foo", O_WRONLY | O_CREAT, 0644);
 7 |   write(fd, "hello world", 11);
 8 |   close(fd);
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/samples/clang/hello.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | // using namespace std;
 3 | 
 4 | int main() {
 5 |    std::cout << "Hello, world!" << std::endl;
 6 |    return 0;
 7 | }
 8 | 
 9 | 
10 | // meta.preprocessor.include.c string.quoted.other.lt-gt.include.c
11 | // source.cpp meta.preprocessor.include.c string.quoted.other.lt-gt.include.c punctuation.definition.string.begin.c
12 | // source.cpp meta.preprocessor.include.c string.quoted.other.lt-gt.include.c punctuation.definition.string.begin.c
13 | // source.cpp meta.preprocessor.include.c string.quoted.other.lt-gt.include.c punctuation.definition.string.begin.c
14 | 


--------------------------------------------------------------------------------
/test/samples/clang/issue-4.cc:
--------------------------------------------------------------------------------
1 | uint64_t clint_timer_get_freq(void)
2 | {
3 |     /* The clock is divided by CLINT_CLOCK_DIV */
4 |     return sysctl_clock_get_freq(SYSCTL_CLOCK_CPU) / CLINT_CLOCK_DIV;
5 | }
6 | 


--------------------------------------------------------------------------------
/test/samples/clang/read.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | 
 4 | int main()
 5 | {
 6 |     int c;
 7 |     FILE *file;
 8 |     file = fopen("hello.txt", "r");
 9 | 
10 |     if(file == NULL)
11 |     {
12 |         printf("Error!");
13 |         exit(1);
14 |     }
15 | 
16 |     if (file)
17 |     {
18 |         while((c = getc(file)) != EOF)
19 |             putchar(c);
20 |         fclose(file);
21 |     }
22 | 
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/test/samples/clang/vars.c:
--------------------------------------------------------------------------------
 1 | int X;
 2 | int y;
 3 | 
 4 | f(double x)
 5 | {
 6 |     double y;
 7 |     ...
 8 | }
 9 | 
10 | int sp = 0;
11 | double val[MAXVAL];
12 | 
13 | 
14 | int low, high, mid;
15 | 
16 | register int x;
17 | register char c;
18 | 
19 | extern int sp;
20 | extern double val[];
21 | 
22 | void push(double f) {/*...*/}
23 | 
24 | double pop(void) {/*...*/}
25 | 
26 | int x = 1, y = 2, z[10];
27 | int *ip;      /* ip is a pointer to int */
28 | 
29 | ip = &x;      /* ip now points to x */
30 | y = *ip;      /* y is now 1 */
31 | *ip = 0;      /* x is now 0 */
32 | ip = &z[O];   /* ip now points to z[O] */
33 | 


--------------------------------------------------------------------------------
/test/samples/crystal/bindings.cr:
--------------------------------------------------------------------------------
 1 | # Fragment of the BigInt implementation that uses GMP
 2 | @[Link("gmp")]
 3 | lib LibGMP
 4 |   alias Int = LibC::Int
 5 |   alias ULong = LibC::ULong
 6 | 
 7 |   struct MPZ
 8 |     _mp_alloc : Int32
 9 |     _mp_size : Int32
10 |     _mp_d : ULong*
11 |   end
12 | 
13 |   fun init_set_str = __gmpz_init_set_str(rop : MPZ*, str : UInt8*, base : Int) : Int
14 |   fun cmp = __gmpz_cmp(op1 : MPZ*, op2 : MPZ*) : Int
15 | end
16 | 
17 | struct BigInt < Int
18 |   def initialize(str : String, base = 10)
19 |     err = LibGMP.init_set_str(out @mpz, str, base)
20 |     raise ArgumentError.new("invalid BigInt: #{str}") if err == -1
21 |   end
22 | 
23 |   def <=>(other : BigInt)
24 |     LibGMP.cmp(mpz, other)
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/test/samples/crystal/greeter.cr:
--------------------------------------------------------------------------------
 1 | class Greeter
 2 |     # property name : String
 3 |     # property salutation : String
 4 |     @name : String
 5 |     @salutation : String
 6 | 
 7 |     def initialize(@name, @salutation)
 8 |       # @name = name
 9 |       # @salutation = salutation
10 |     end
11 | 
12 |     def greet
13 |       puts "Hey"
14 |     end
15 | 
16 |     def salute
17 |       puts "#{@salutation} #{@name}!"
18 |     end
19 | 
20 |   end
21 | 
22 |   c = Greeter.new("Clay", "Wazzupp")
23 |   c.salute
24 | 


--------------------------------------------------------------------------------
/test/samples/css/animation.2.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 | <style>
 5 | div {
 6 |     width: 100px;
 7 |     height: 100px;
 8 |     background-color: red;
 9 |     position: relative;
10 |     -webkit-animation: myfirst 5s linear 2s infinite alternate; /* Safari 4.0 - 8.0 */
11 |     animation: myfirst 5s linear 2s infinite alternate;
12 | }
13 | 
14 | /* Safari 4.0 - 8.0 */
15 | @-webkit-keyframes myfirst {
16 |     0%   {background-color:red; left:0px; top:0px;}
17 |     25%  {background-color:yellow; left:200px; top:0px;}
18 |     50%  {background-color:blue; left:200px; top:200px;}
19 |     75%  {background-color:green; left:0px; top:200px;}
20 |     100% {background-color:red; left:0px; top:0px;}
21 | }
22 | 
23 | /* Standard syntax */
24 | @keyframes myfirst {
25 |     0%   {background-color:red; left:0px; top:0px;}
26 |     25%  {background-color:yellow; left:200px; top:0px;}
27 |     50%  {background-color:blue; left:200px; top:200px;}
28 |     75%  {background-color:green; left:0px; top:200px;}
29 |     100% {background-color:red; left:0px; top:0px;}
30 | }
31 | </style>
32 | </head>
33 | <body>
34 | 
35 | <p><b>Note:</b> This example does not work in Internet Explorer 9 and earlier versions.</p>
36 | 
37 | <div></div>
38 | 
39 | </body>
40 | </html>
41 | 
42 | 


--------------------------------------------------------------------------------
/test/samples/css/animation.css:
--------------------------------------------------------------------------------
 1 | div {
 2 |     width: 100px;
 3 |     height: 100px;
 4 |     background-color: red;
 5 |     position: relative;
 6 |     -webkit-animation-name: example; /* Safari 4.0 - 8.0 */
 7 |     -webkit-animation-duration: 4s; /* Safari 4.0 - 8.0 */
 8 |     -webkit-animation-iteration-count: 2; /* Safari 4.0 - 8.0 */
 9 |     -webkit-animation-direction: alternate; /* Safari 4.0 - 8.0 */
10 |     animation-name: example;
11 |     animation-duration: 4s;
12 |     animation-iteration-count: 2;
13 |     animation-direction: alternate;
14 | }
15 | 
16 | /* Safari 4.0 - 8.0 */
17 | @-webkit-keyframes example {
18 |     0%   {background-color:red; left:0px; top:0px;}
19 |     25%  {background-color:yellow; left:200px; top:0px;}
20 |     50%  {background-color:blue; left:200px; top:200px;}
21 |     75%  {background-color:green; left:0px; top:200px;}
22 |     100% {background-color:red; left:0px; top:0px;}
23 | }
24 | 
25 | /* Standard syntax */
26 | @keyframes example {
27 |     0%   {background-color:red; left:0px; top:0px;}
28 |     25%  {background-color:yellow; left:200px; top:0px;}
29 |     50%  {background-color:blue; left:200px; top:200px;}
30 |     75%  {background-color:green; left:0px; top:200px;}
31 |     100% {background-color:red; left:0px; top:0px;}
32 | }
33 | 


--------------------------------------------------------------------------------
/test/samples/css/animation.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 | <style>
 5 | div {
 6 |     width: 100px;
 7 |     height: 100px;
 8 |     background-color: red;
 9 |     position: relative;
10 |     -webkit-animation-name: example; /* Safari 4.0 - 8.0 */
11 |     -webkit-animation-duration: 4s; /* Safari 4.0 - 8.0 */
12 |     -webkit-animation-iteration-count: 2; /* Safari 4.0 - 8.0 */
13 |     -webkit-animation-direction: alternate; /* Safari 4.0 - 8.0 */
14 |     animation-name: example;
15 |     animation-duration: 4s;
16 |     animation-iteration-count: 2;
17 |     animation-direction: alternate;
18 | }
19 | 
20 | /* Safari 4.0 - 8.0 */
21 | @-webkit-keyframes example {
22 |     0%   {background-color:red; left:0px; top:0px;}
23 |     25%  {background-color:yellow; left:200px; top:0px;}
24 |     50%  {background-color:blue; left:200px; top:200px;}
25 |     75%  {background-color:green; left:0px; top:200px;}
26 |     100% {background-color:red; left:0px; top:0px;}
27 | }
28 | 
29 | /* Standard syntax */
30 | @keyframes example {
31 |     0%   {background-color:red; left:0px; top:0px;}
32 |     25%  {background-color:yellow; left:200px; top:0px;}
33 |     50%  {background-color:blue; left:200px; top:200px;}
34 |     75%  {background-color:green; left:0px; top:200px;}
35 |     100% {background-color:red; left:0px; top:0px;}
36 | }
37 | </style>
38 | </head>
39 | <body>
40 | 
41 | <p><b>Note:</b> This example does not work in Internet Explorer 9 and earlier versions.</p>
42 | 
43 | <div></div>
44 | 
45 | </body>
46 | </html>
47 | 


--------------------------------------------------------------------------------
/test/samples/css/animation.scss:
--------------------------------------------------------------------------------
 1 | .hi {
 2 |     width: 50px;
 3 |     height: 72px;
 4 |     background-image: url("http://s.cdpn.io/79/sprite-steps.png");
 5 | 
 6 |     -webkit-animation: play .8s steps(10) infinite;
 7 |        -moz-animation: play .8s steps(10) infinite;
 8 |         -ms-animation: play .8s steps(10) infinite;
 9 |          -o-animation: play .8s steps(10) infinite;
10 |             animation: play .8s steps(10) infinite;
11 | }
12 | 
13 | @-webkit-keyframes play {
14 |    from { background-position:    0px; }
15 |      to { background-position: -500px; }
16 | }
17 | 
18 | @-moz-keyframes play {
19 |    from { background-position:    0px; }
20 |      to { background-position: -500px; }
21 | }
22 | 
23 | @-ms-keyframes play {
24 |    from { background-position:    0px; }
25 |      to { background-position: -500px; }
26 | }
27 | 
28 | @-o-keyframes play {
29 |    from { background-position:    0px; }
30 |      to { background-position: -500px; }
31 | }
32 | 
33 | @keyframes play {
34 |    from { background-position:    0px; }
35 |      to { background-position: -500px; }
36 | }
37 | 
38 | @keyframes fontbulger {
39 |     0% {
40 |       font-size: 10px;
41 |     }
42 |     30% {
43 |       font-size: 15px;
44 |     }
45 |     100% {
46 |       font-size: 12px;
47 |     }
48 |   }
49 | 
50 |   #box {
51 |      animation: fontbulger 2s infinite;
52 |   }
53 | 


--------------------------------------------------------------------------------
/test/samples/css/boxes.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <title> Using Transform </title>
 6 |     <style>
 7 |         body {
 8 |             padding-bottom: 200px;
 9 |         }
10 |         h2 {
11 |             border-bottom: solid 1px #333;
12 |         }
13 |         .box {
14 |             width: 200px;
15 |             height: 200px;
16 |             transition: transform 2s;
17 |         }
18 | 
19 |         /** Box 1 **/
20 |         #box1 {
21 |             background-color: blue;
22 |         }
23 |         #box1:hover {
24 |             transform: translateX(-100px);
25 |         }
26 | 
27 |         /** Box 2 **/
28 |         #box2 {
29 |             background-color: green;
30 |         }
31 |         #box2:hover {
32 |             transform: translate(-100px, -100px);
33 |         }
34 | 
35 |         /** Box 3 **/
36 |         #box3 {
37 |             background-color: red;
38 |             margin: auto;
39 |         }
40 |         #box3:hover {
41 |             transform: scale(.5);
42 |         }
43 | 
44 |         /** Box 4 **/
45 |         #box4 {
46 |             background-color: purple;
47 |             margin: auto;
48 |         }
49 |         #box4:hover {
50 |             transform: rotate(-122deg);
51 |         }
52 |     </style>
53 | </head>
54 | <body>
55 |     <h2> Box 1 </h2>
56 |     <div class="box" id="box1"></div>
57 |     <h2> Box 2 </h2>
58 |     <div class="box" id="box2"></div>
59 |     <h2> Box 3 </h2>
60 |     <div class="box" id="box3"></div>
61 |     <h2> Box 4 </h2>
62 |     <div class="box" id="box4"></div>
63 | </body>
64 | </html>
65 | 


--------------------------------------------------------------------------------
/test/samples/css/custom-properties.css:
--------------------------------------------------------------------------------
 1 | /* https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties */
 2 | 
 3 | :root {
 4 |     --main-bg-color: brown;
 5 | }
 6 | 
 7 | .one {
 8 |     color: white;
 9 |     background-color: var(--main-bg-color);
10 |     margin: 10px;
11 |     width: 50px;
12 |     height: 50px;
13 |     display: inline-block;
14 | }
15 | 
16 | .two {
17 |     color: white;
18 |     background-color: black;
19 |     margin: 10px;
20 |     width: 150px;
21 |     height: 70px;
22 |     display: inline-block;
23 | }
24 | 
25 | .three {
26 |     color: white;
27 |     background-color: var(--main-bg-color);
28 |     margin: 10px;
29 |     width: 75px;
30 | }
31 | 
32 | .four {
33 |     color: white;
34 |     background-color: var(--main-bg-color);
35 |     margin: 10px;
36 |     width: 100px;
37 | }
38 | 
39 | .five {
40 |     background-color: var(--main-bg-color);
41 | }
42 | 
43 | .two {
44 |     color: var(--my-var, red);
45 |     /* Red if --my-var is not defined */
46 | }
47 | 
48 | .three {
49 |     background-color: var(--my-var, var(--my-background, pink));
50 |     /* pink if --my-var and --my-background are not defined */
51 | }
52 | 
53 | .three {
54 |     background-color: var(--my-var, --my-background, pink);
55 |     /* Invalid: "--my-background, pink" */
56 | }


--------------------------------------------------------------------------------
/test/samples/css/drawer.css:
--------------------------------------------------------------------------------
 1 | test {
 2 | position: fixed;
 3 | width: 280px;
 4 | min-width: 70px;
 5 | height: 100%;
 6 | left: 0;
 7 | top: 0;
 8 | z-index: 200;
 9 | background-color: #fff;
10 | padding: 32px 16px;
11 | box-sizing: border-box;
12 | transition: transform 0.3s ease-out;
13 | /* transform: ${props => (props.open ? 'translateX(0)' : 'translateX(-100vh)')}; */
14 | }
15 | /* &.Open {
16 |   transform: translateX(0);
17 | }
18 | 
19 | &.Close {
20 |   transform: translateX(-100vh);
21 | } */
22 | 
23 | /* FIXME: broken syntax by media rule maybe */
24 | @media (min-width: 500px) {
25 |   display: none;
26 | }
27 | 


--------------------------------------------------------------------------------
/test/samples/css/operators.scss:
--------------------------------------------------------------------------------
1 | .title.lg {
2 |     font-size: $font-size-regular+20px;
3 | 
4 |     span {
5 |       font-size: $font-size-regular + 4px;
6 |     }
7 |   }
8 | 


--------------------------------------------------------------------------------
/test/samples/css/test.scss:
--------------------------------------------------------------------------------
 1 | .toolbar {
 2 |     display: grid;
 3 |     align-items: center;
 4 |     grid-template-columns: 1fr 1fr;
 5 |     padding: 0 30px 0 30px;
 6 | 
 7 |     @media screen and (max-width: 768px) {
 8 |       padding: 0;
 9 |     }
10 | 
11 |     .sorting-tools {
12 |       display: flex;
13 |       flex-direction: row;
14 | 
15 |       :nth-child(n) {
16 |         margin-right: 5px;
17 |       }
18 |     }
19 | 
20 |     .filtering-tools {
21 |       justify-self: right;
22 |     }
23 |     @include breakpoint(bigscreens) {
24 |         height: 780px;
25 |       }
26 |   }
27 | 


--------------------------------------------------------------------------------
/test/samples/elixir/blanks.exs:
--------------------------------------------------------------------------------
 1 | defmodule Blanks do
 2 |   def replace(ast, replacements) do
 3 |     replacements = List.wrap(replacements)
 4 |     ast
 5 |     |> Macro.prewalk(replacements, &pre/2)
 6 |     |> elem(0)
 7 |   end
 8 | 
 9 |   defp pre({:assert_receive, _, args} = node, replacements) do
10 |     {args, replacements} = Macro.prewalk(args, replacements, &pre_pin/2)
11 |     {put_elem(node, 2, args), replacements}
12 |   end
13 |   defp pre({:___, _, _}, [first | remainder]), do: {first, remainder}
14 |   defp pre(node, acc), do: {node, acc}
15 | 
16 |   defp pre_pin({:___, _, _}, [first | remainder]), do: {pin(first), remainder}
17 |   defp pre_pin(node, acc), do: {node, acc}
18 | 
19 |   defp pin(var) when is_tuple(var) do
20 |     quote do
21 |       ^unquote(var)
22 |     end
23 |   end
24 |   defp pin(var), do: var
25 | 
26 |   def count(ast) do
27 |     ast
28 |     |> Macro.prewalk(0, &count/2)
29 |     |> elem(1)
30 |   end
31 | 
32 |   defp count({:___, _, _} = node, acc), do: {node, acc+1}
33 |   defp count(node, acc), do: {node, acc}
34 | 
35 |   def replace_line({:__block__, meta, lines}, replacement_fn) do
36 |     replaced_lines = Enum.map(lines, fn(line) ->
37 |       replace_line(line, replacement_fn)
38 |     end)
39 | 
40 |     {:__block__, meta, replaced_lines}
41 |   end
42 |   def replace_line(line, replacement_fn) do
43 |     if count(line) > 0 do
44 |       replacement_fn.(line)
45 |     else
46 |       line
47 |     end
48 |   end
49 | end
50 | 


--------------------------------------------------------------------------------
/test/samples/elixir/erlang/greeter.erl:
--------------------------------------------------------------------------------
 1 | %% greeter.erl
 2 | %% Greets people and counts number of times it did so.
 3 | -module(greeter).
 4 | -behaviour(gen_server).
 5 | %% Export API Functions
 6 | -export([start_link/0, greet/1, get_count/0]).
 7 | %% Required gen server callbacks
 8 | -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 9 | 
10 | -record(state, {count::integer()}).
11 | 
12 | %% Public API
13 | start_link() ->
14 |     gen_server:start_link({local, ?MODULE}, ?MODULE, {}, []).
15 | 
16 | greet(Name) ->
17 |     gen_server:cast(?MODULE, {greet, Name}).
18 | 
19 | get_count() ->
20 |     gen_server:call(?MODULE, {get_count}).
21 | 
22 | %% Private
23 | init({}) ->
24 |     {ok, #state{count=0}}.
25 | 
26 | handle_cast({greet, Name}, #state{count = Count} = State) ->
27 |     io:format("Greetings ~s!~n", [Name]),
28 |     {noreply, State#state{count = Count + 1}};
29 | 
30 | handle_cast(Msg, State) ->
31 |     error_logger:warning_msg("Bad message: ~p~n", [Msg]),
32 |     {noreply, State}.
33 | 
34 | handle_call({get_count}, _From, State) ->
35 |     {reply, {ok, State#state.count}, State};
36 | 
37 | handle_call(Request, _From, State) ->
38 |     error_logger:warning_msg("Bad message: ~p~n", [Request]),
39 |     {reply, {error, unknown_call}, State}.
40 | 
41 | %% Other gen_server callbacks
42 | handle_info(Info, State) ->
43 |     error_logger:warning_msg("Bad message: ~p~n", [Info]),
44 |     {noreply, State}.
45 | 
46 | terminate(_Reason, _State) ->
47 |     ok.
48 | 
49 | code_change(_OldVsn, State, _Extra) ->
50 |     {ok, State}.
51 | 


--------------------------------------------------------------------------------
/test/samples/elixir/erlang/hello.erl:
--------------------------------------------------------------------------------
1 | -module(hello_world).
2 | -export([hello/0, hello/1]).
3 | 
4 | hello() ->
5 |     io:format("hello world~n").
6 | 
7 | hello(Name) ->
8 |     io:format("hello ~p~n", [Name]).
9 | 


--------------------------------------------------------------------------------
/test/samples/elixir/failure.ex:
--------------------------------------------------------------------------------
 1 | defmodule Display.Failure do
 2 |   alias Display.Paint
 3 | 
 4 |   @no_value :ex_unit_no_meaningful_value
 5 | 
 6 |   def format_failure(%{error: %ExUnit.AssertionError{expr: @no_value, message: message}, file: file, line: line}) do
 7 |     """
 8 |     #{Paint.cyan("Assertion failed in #{file}:#{line}")}
 9 |     #{Paint.red(message)}
10 |     """
11 |   end
12 |   def format_failure(%{error: %ExUnit.AssertionError{expr: expr} = error, file: file, line: line}) do
13 |     """
14 |     #{Paint.cyan("Assertion failed in #{file}:#{line}")}
15 |     #{Paint.red(Macro.to_string(expr))}
16 |     """
17 |     |> format_inequality(error)
18 |   end
19 |   def format_failure(%{error: error, file: file, line: line}) do
20 |     """
21 |     #{Paint.cyan("Error in #{file}:#{line}")}
22 |     #{format_error(error)}
23 |     """
24 |   end
25 | 
26 |   defp format_inequality(message, %{left: @no_value, right: @no_value}) do
27 |     message
28 |   end
29 |   defp format_inequality(message, %{left: @no_value, right: match_value}) do
30 |     """
31 |     #{message}
32 |     value does not match: #{match_value |> inspect |> Paint.yellow}
33 |     """
34 |   end
35 |   defp format_inequality(message, %{left: left, right: right}) do
36 |     """
37 |     #{message}
38 |     left:  #{left |> inspect |> Paint.yellow}
39 |     right: #{right |> inspect |> Paint.yellow}
40 |     """
41 |   end
42 | 
43 |   defp format_error(e2rror) do
44 |     trace = System.stacktrace |> Enum.take(2)
45 |     Paint.red(Exception.format(:error, error, trace))
46 |   end
47 | 
48 |   def show_compile_error(error) do
49 |     format_error(error)
50 |   end
51 | end
52 | 


--------------------------------------------------------------------------------
/test/samples/elixir/file_system.ex:
--------------------------------------------------------------------------------
 1 | defmodule FileSystem do
 2 |   @moduledoc File.read!("README.md")
 3 | 
 4 |   @doc """
 5 |   ## Options
 6 | 
 7 |     * `:dirs` ([string], requires), the dir list to monitor
 8 | 
 9 |     * `:backend` (atom, optional), default backends: `:fs_mac`
10 |       for `macos`, `:fs_inotify` for `linux` and `freebsd`,
11 |       `:fs_windows` for `windows`
12 | 
13 |     * `:name` (atom, optional), `name` can be used to subscribe as
14 |       the same as pid when the `name` is given. The `name` should
15 |       be the name of worker process.
16 | 
17 |     * All rest options will treated as backend options. See backend
18 |       module documents for more details.
19 | 
20 |   ## Example
21 | 
22 |   Simple usage:
23 | 
24 |       iex> {:ok, pid} = FileSystem.start_link(dirs: ["/tmp/fs"])
25 |       iex> FileSystem.subscribe(pid)
26 | 
27 |   Get instant notifications on file changes for Mac OS X:
28 | 
29 |       iex> FileSystem.start_link(dirs: ["/path/to/some/files"], latency: 0)
30 | 
31 |   Named monitor with specified backend:
32 | 
33 |       iex> FileSystem.start_link(backend: :fs_mac, dirs: ["/tmp/fs"], name: :worker)
34 |       iex> FileSystem.subscribe(:worker)
35 |   """
36 |   @spec start_link(Keyword.t) :: {:ok, pid}
37 |   def start_link(options, npndqw) do
38 |     FileSystem.Worker.start_link(options)
39 |   end
40 | 
41 |   @doc """
42 |   Register the current process as a subscriber of a file_system worker.
43 |   The pid you subscribed from will now receive messages like
44 | 
45 |       {:file_event, worker_pid, {file_path, events}}
46 |       {:file_event, worker_pid, :stop}
47 |   """
48 |   @spec subscribe(pid() | atom()) :: :ok
49 |   def subscribe(pid) do
50 |     GenServer.call(pid, :subscribe)
51 |   end
52 | end
53 | 


--------------------------------------------------------------------------------
/test/samples/elixir/kv.ex:
--------------------------------------------------------------------------------
 1 | defmodule KV.Bucket do
 2 |     use Agent
 3 | 
 4 |     @doc """
 5 |     Starts a new bucket.
 6 |     """
 7 |     def start_link(_opts) do
 8 |       Agent.start_link(fn -> %{} end)
 9 |     end
10 | 
11 |     @doc """
12 |     Gets a value from the `bucket` by `key`.
13 |     """
14 |     def get(bucket, key) do
15 |       Agent.get(bucket, &Map.get(&1, key))
16 |     end
17 | 
18 |     @doc """
19 |     Puts the `value` for the given `key` in the `bucket`.
20 |     """
21 |     def put(bucket, key, value) do
22 |       Agent.update(bucket, &Map.put(&1, key, value))
23 |     end
24 |   end
25 | 


--------------------------------------------------------------------------------
/test/samples/elixir/macro.ex:
--------------------------------------------------------------------------------
 1 | defmodule Discuss.Router do
 2 |   use Discuss.Web, :router
 3 | 
 4 |   pipeline :browser do
 5 |     plug(:accepts, ["html"])
 6 |     plug(:fetch_session)
 7 |     plug(:fetch_flash)
 8 |     plug(:protect_from_forgery)
 9 |     plug(:put_secure_browser_headers)
10 |     plug(Discuss.Plugs.SetUser)
11 |   end
12 | 
13 |   pipeline :api do
14 |     plug(:accepts, ["json"])
15 |   end
16 | 
17 |   scope "/", Discuss do
18 |     pipe_through(:browser)
19 | 
20 |     resources("/", TopicController)
21 | 
22 |     get("/", TopicController, :index)
23 |     get("/topics/new", TopicController, :new)
24 |     post("/topics", TopicController, :create)
25 |     get("/topics/:id/edit", TopicController, :edit)
26 |     put("/topics/:id", TopicController, :update)
27 |     delete("/topics/:id", TopicController, :delete)
28 |   end
29 | 
30 |   scope "/auth", Discuss do
31 |     pipe_through(:browser)
32 | 
33 |     get("/signout", AuthController, :signout)
34 |     get("/:provider", AuthController, :request)
35 |     get("/:provider/callback", AuthController, :callback)
36 |   end
37 | end
38 | 


--------------------------------------------------------------------------------
/test/samples/elixir/math.exs:
--------------------------------------------------------------------------------
1 | defmodule ModulePlayground.Misc.Util.Math do
2 |   def add(a, b, araf, afwafa) do
3 |     a + b
4 |   end
5 | end
6 | 


--------------------------------------------------------------------------------
/test/samples/elixir/oper.exs:
--------------------------------------------------------------------------------
 1 | defmodule Sample.Enum do
 2 | 
 3 |   # def first(list) do
 4 |   #   hd(list)
 5 |   # end
 6 | 
 7 |   # def first([]) do
 8 |   #   nil
 9 |   # end
10 | 
11 |   # def first([head | _tail]) do
12 |   #   head
13 |   # end
14 | 
15 |   # def first(list) when length(list) == 0, do: nil
16 | 
17 |   def first(list, val \\ nil), do: val
18 |   def first([head | _tail], val), do: head
19 |   def first([], val \\ nil), do: val
20 | 
21 |   def add(list, val \\ 0) do
22 |     [val | list]
23 |   end
24 | 
25 | end
26 | 


--------------------------------------------------------------------------------
/test/samples/elixir/oper2.ex:
--------------------------------------------------------------------------------
 1 | defmodule Discuss.TopicController do
 2 |   use Discuss.Web, :controller
 3 | 
 4 |   alias Discuss.Topic
 5 | 
 6 |   def edit(conn, %{"id" => topic_id}) do
 7 | 
 8 |   end
 9 | 
10 |   def index(conn, _params) do
11 |     topics = Repo.all(Topic)
12 |     render(conn, "index.html", topics: topics)
13 |   end
14 | 
15 |   def new(conn, _params) do
16 |     changeset = Topic.changeset(%Topic{}, %{})
17 |     render(conn, "new.html", changeset: changeset)
18 |   end
19 | 
20 |   def create(conn, %{"topic" => topic}) do
21 |     changeset = Topic.changeset(%Topic{}, topic)
22 | 
23 |     case Repo.insert(changeset) do
24 |       {:ok, _post} ->
25 |         conn
26 |         |> redirect(to: topic_path(conn, :index))
27 |       {:error, changeset} -> render(conn, "new.html", changeset: changeset)
28 |     end
29 |   end
30 | 
31 | end
32 | 


--------------------------------------------------------------------------------
/test/samples/elixir/pipe.ex:
--------------------------------------------------------------------------------
 1 | defmodule Discuss.AuthController do
 2 |   use Discuss.Web, :controller
 3 | 
 4 |   alias Discuss.User
 5 | 
 6 |   plug(Ueberauth)
 7 | 
 8 | 
 9 |   def callback(%{assigns: %{ueberauth_auth: auth}} = conn, _params) do
10 |     user_params = %{
11 |       token: auth.credentials.token,
12 |       email: auth.info.email,
13 |       provider: "github"
14 |     }
15 |     changeset = User.changeset(%User{}, user_params)
16 | 
17 |     signin(conn, changeset)
18 |   end
19 | 
20 |   def signout(conn, _params) do
21 |     conn
22 |     |> configure_session(drop: true)  # Drop the entire session, don't just deactivate it
23 |     |> redirect(to: topic_path(conn, :index))
24 |   end
25 | 
26 |   defp signin(conn, changeset) do
27 |     case insert_or_update_user(changeset) do
28 |       {:ok, user} ->
29 |         conn
30 |         |> put_flash(:info, "Welcome Back")
31 |         |> put_session(:user_id, user.id)
32 |         |> redirect(to: topic_path(conn, :index))
33 | 
34 |       {:error, _reason} ->
35 |         conn
36 |         |> put_flash(:info, "Error signing in")
37 |         |> redirect(to: topic_path(conn, :index))
38 |     end
39 | 
40 |   end
41 | 
42 |   defp insert_or_update_user(changeset) do
43 |     case Repo.get_by(User, email: changeset.changes.email) do
44 |       nil ->
45 |         Repo.insert(changeset)
46 |       user ->
47 |         {:ok, user}
48 |     end
49 |   end
50 | 
51 | end
52 | 


--------------------------------------------------------------------------------
/test/samples/elixir/reader.ex:
--------------------------------------------------------------------------------
1 | defmodule HelloWorld.FileReader do
2 | 
3 |   def get_strings_to_tweet(path) do
4 |     File.read!(path)
5 |     |> String.split("\n")
6 |   end
7 | 
8 | end
9 | 


--------------------------------------------------------------------------------
/test/samples/elixir/small_test.ex:
--------------------------------------------------------------------------------
1 | defmodule HelloWeb.PageControllerTest do
2 |   use HelloWeb.ConnCase
3 | 
4 |   test "GET /", %{conn: conn} do
5 |     conn = get(conn, "/")
6 |     assert html_response(conn, 200) =~ "Welcome to Phoenix!"
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/test/samples/elm/increment.elm:
--------------------------------------------------------------------------------
 1 | {-- https://guide.elm-lang.org/ --}
 2 | 
 3 | import Browser
 4 | import Html exposing (Html, button, div, text)
 5 | import Html.Events exposing (onClick)
 6 | 
 7 | main =
 8 |   Browser.sandbox { init = 0, update = update, view = view }
 9 | 
10 | type Msg = Increment | Decrement
11 | 
12 | update msg model =
13 |   case msg of
14 |     Increment ->
15 |       model + 1
16 | 
17 |     Decrement ->
18 |       model - 1
19 | 
20 | view model =
21 |   div []
22 |     [ button [ onClick Decrement ] [ text "-" ]
23 |     , div [] [ text (String.fromInt model) ]
24 |     , button [ onClick Increment ] [ text "+" ]
25 |     ]
26 | 


--------------------------------------------------------------------------------
/test/samples/elm/main.elm:
--------------------------------------------------------------------------------
 1 | module App exposing (main)
 2 | 
 3 | import Html
 4 | import Container.State exposing (..)
 5 | import Container.View exposing (..)
 6 | import Container.Types exposing (..)
 7 | 
 8 | main : Program Never Model Msg
 9 | main =
10 |     Html.program
11 |         { init = init
12 |         , view = view
13 |         , update = update
14 |         , subscriptions = subscriptions
15 |         }
16 | 


--------------------------------------------------------------------------------
/test/samples/elm/radio.elm:
--------------------------------------------------------------------------------
 1 | module Main exposing (..)
 2 | 
 3 | import Html exposing (Html, div, button, audio, text)
 4 | import Html.Events exposing (onClick)
 5 | import Html.Attributes exposing (src, autoplay, controls)
 6 | 
 7 | main : Program Never Model Msg
 8 | main =
 9 |     Html.beginnerProgram
10 |         { view = view
11 |         , model = Model False "http://stream-tx4.radioparadise.com/mp3-192"
12 |         , update = update
13 |         }
14 | 
15 | 
16 | type alias Model =
17 |     { playing : Bool
18 |     , src : String
19 |     }
20 | 
21 | 
22 | type Msg
23 |     = Play
24 |     | Pause
25 | 
26 | 
27 | update : Msg -> Model -> Model
28 | update msg model =
29 |     case msg of
30 |         Play ->
31 |             { model | playing = True }
32 | 
33 |         Pause ->
34 |             { model | playing = False }
35 | 
36 | 
37 | view : Model -> Html Msg
38 | view model =
39 |     if model.playing then
40 |         playingView model
41 |     else
42 |         notPlayingView model
43 | 
44 | 
45 | playingView : Model -> Html Msg
46 | playingView model =
47 |     div []
48 |         [ button [ onClick Pause ] [ text "Pause" ]
49 |         , audio [ src model.src, autoplay True, controls True ] []
50 |         ]
51 | 
52 | 
53 | notPlayingView : Model -> Html Msg
54 | notPlayingView model =
55 |     button [ onClick Play ] [ text "Play" ]
56 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/json/italic.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "editor.tokenColorCustomizations": {
 3 |     "textMateRules": [
 4 |       {
 5 |         "scope": "comment",
 6 |         "settings": {
 7 |           "fontStyle": "italic"
 8 |         }
 9 |       }
10 |     ]
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/json/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "dark-plus-syntax",
 3 | 	"displayName": "dark-plus-syntax",
 4 | 	"description": "VS Code's default dark theme, but just a little bit better.",
 5 | 	"version": "0.0.157",
 6 | 	"publisher": "dunstontc",
 7 | 	"license": "MIT",
 8 | 	"repository": {
 9 | 		"type": "git",
10 | 		"url": "https://github.com/dunstontc/dark-plus-syntax.git"
11 | 	},
12 | 	"engines": {"vscode": "^1.15.0"},
13 | 	"categories": ["Themes"],
14 | 	"contributes": {
15 | 		"themes": [
16 | 			{
17 | 				"label": "dark-plus-syntax",
18 | 				"uiTheme": "vs-dark",
19 | 				"path": "./themes/dark-plus-syntax-color-theme.json"
20 | 			}
21 | 		]
22 | 	},
23 | 	"devDependencies": {
24 | 		"write-json-file": "^2.2.0"
25 | 	},
26 | 	"scripts": {
27 |         "build": "node index.js",
28 |         "publish": "vsce publish"
29 |     },
30 | 	"galleryBanner": {
31 | 		"color": "#569cd6",
32 | 		"theme": "dark"
33 | 	},
34 | 	"icon": "assets/128.png",
35 | 	"__metadata": {
36 | 		"id": "dd7e0ff7-9eb5-45fe-8b21-00e79b632b7f",
37 | 		"publisherDisplayName": "dunstontc",
38 | 		"publisherId": "564ecb85-8c09-42fc-b2da-902737b2e743"
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/toml/Gopkg.toml:
--------------------------------------------------------------------------------
 1 | # Gopkg.toml example
 2 | #
 3 | # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
 4 | # for detailed Gopkg.toml documentation.
 5 | #
 6 | # required = ["github.com/user/thing/cmd/thing"]
 7 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
 8 | #
 9 | # [[constraint]]
10 | #   name = "github.com/user/project"
11 | #   version = "1.0.0"
12 | #
13 | # [[constraint]]
14 | #   name = "github.com/user/project2"
15 | #   branch = "dev"
16 | #   source = "github.com/myfork/project2"
17 | #
18 | # [[override]]
19 | #   name = "github.com/x/y"
20 | #   version = "2.4.0"
21 | #
22 | # [prune]
23 | #   non-go = false
24 | #   go-tests = true
25 | #   unused-packages = true
26 | 
27 | 
28 | [[constraint]]
29 |   name = "github.com/google/go-github"
30 |   version = "15.0.0"
31 | 
32 | [[constraint]]
33 |   branch = "master"
34 |   name = "golang.org/x/crypto"
35 | 
36 | [prune]
37 |   go-tests = true
38 |   unused-packages = true
39 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/toml/example.toml:
--------------------------------------------------------------------------------
 1 | # This is a TOML document. Boom.
 2 | 
 3 | title = "TOML Example"
 4 | 
 5 | [owner]
 6 | name = "Tom Preston-Werner"
 7 | organization = "GitHub"
 8 | bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
 9 | dob = 1979-05-27T07:32:00Z # First class dates? Why not?
10 | 
11 | [database]
12 | server = "192.168.1.1"
13 | ports = [ 8001, 8001, 8002 ]
14 | connection_max = 5000
15 | enabled = true
16 | 
17 | [servers]
18 | 
19 |   # You can indent as you please. Tabs or spaces. TOML don't care.
20 |   [servers.alpha]
21 |   ip = "10.0.0.1"
22 |   dc = "eqdc10"
23 | 
24 |   [servers.beta]
25 |   ip = "10.0.0.2"
26 |   dc = "eqdc10"
27 |   country = "中国" # This should be parsed as UTF-8
28 | 
29 | [clients]
30 | data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
31 | 
32 | # Line breaks are OK when inside arrays
33 | hosts = [
34 |   "alpha",
35 |   "omega"
36 | ]
37 | 
38 | # Products
39 | 
40 |   [[products]]
41 |   name = "Hammer"
42 |   sku = 738594937
43 | 
44 |   [[products]]
45 |   name = "Nail"
46 |   sku = 284758393
47 |   color = "gray"
48 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/yaml/appveyor.yml:
--------------------------------------------------------------------------------
 1 | image: Visual Studio 2017
 2 | 
 3 | # Fix line endings in Windows. (runs before repo cloning)
 4 | init:
 5 |   - git config --global core.autocrlf input
 6 | 
 7 | environment:
 8 |   matrix:
 9 |     - nodejs_version: 8
10 | 
11 | # Finish on first failed build
12 | matrix:
13 |   fast_finish: true
14 | 
15 | platform:
16 |   - x64
17 | 
18 | branches:
19 |   only:
20 |     - master
21 | 
22 | # Disable Visual Studio build and deploy
23 | build: off
24 | deploy: off
25 | 
26 | install:
27 |   - ps: Install-Product node $env:nodejs_version $env:platform
28 |   - yarn install
29 | 
30 | test_script:
31 |   - node --version
32 |   - yarn lint
33 |   - yarn flow
34 |   - yarn build
35 |   - yarn test
36 |   - yarn prettier
37 | 
38 | cache:
39 |  - node_modules
40 |  - "%LOCALAPPDATA%/Yarn"
41 | 


--------------------------------------------------------------------------------
/test/samples/flat-files/yaml/cheat-sheet.yaml:
--------------------------------------------------------------------------------
 1 | # https://www.educative.io/blog/advanced-yaml-syntax-cheatsheet
 2 | 
 3 | definitions:
 4 |   steps:
 5 |     - step: &build-test
 6 |         name: Build and test
 7 |         script:
 8 |           - mvn package
 9 |         artifacts:
10 |           - target/**
11 | 
12 | pipelines:
13 |   branches:
14 |     develop:
15 |       - step: *build-test
16 |     master:
17 |       - step: *build-test
18 | 
19 | ---
20 | # Ruby Psych
21 | dice: !ruby/Object:Dice [3, 6]
22 | 
23 | ---
24 | # perl YAML::XS, YAML.pm, YAML::Syck (Dump and Load)
25 | dice: !!perl/array:Dice [3, 6]
26 | 
27 | ---
28 | # perl YAML.pm, YAML::Syck (Load)
29 | dice: !perl/array:Dice [3, 6]
30 | 
31 | ---
32 | # Pyyaml
33 | dice: !!python/object/new:__main__.Dice
34 |   - !!python/tuple [3, 6]
35 | 


--------------------------------------------------------------------------------
/test/samples/go/accessor.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"sort"
 6 | )
 7 | 
 8 | type people []string
 9 | 
10 | func (p people) Len() int           { return len(p) }
11 | func (p people) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
12 | func (p people) Less(i, j int) bool { return p[i] < p[j] }
13 | 
14 | func main() {
15 | 	studyGroup := people{"Zeno", "John", "Al", "Jenny"}
16 | 
17 | 	fmt.Println(studyGroup)
18 | 	sort.Sort(studyGroup)
19 | 	fmt.Println(studyGroup)
20 | 
21 | }
22 | 
23 | // https://golang.org/pkg/sort/#Sort
24 | // https://golang.org/pkg/sort/#Interface
25 | 


--------------------------------------------------------------------------------
/test/samples/go/bitmask.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | type Day int
 8 | 
 9 | const (
10 | 	SUNDAY Day = iota
11 | 	MONDAY
12 | 	TUESDAY
13 | 	WEDNESDAY
14 | 	THURSDAY
15 | 	FRIDAY
16 | 	SATURDAY
17 | )
18 | 
19 | func day() {
20 | 	fmt.Printf("Monday has the value %d\n", MONDAY)
21 | 	fmt.Printf("Friday has the value %d\n", FRIDAY)
22 | }
23 | 
24 | type Days int
25 | 
26 | const (
27 | 	SUNDAYS Days = 1 << iota
28 | 	MONDAYS
29 | 	TUESDAYS
30 | 	WEDNESDAYS
31 | 	THURSDAYS
32 | 	FRIDAYS
33 | 	SATURDAYS
34 | )
35 | 
36 | func days(d Days) {
37 | 	fmt.Print("\nYou selected these days:\n")
38 | 
39 | 	if d&SUNDAYS != 0 {
40 | 		fmt.Print("* SUNDAY\n")
41 | 	}
42 | 	if d&MONDAYS != 0 {
43 | 		fmt.Print("* MONDAY\n")
44 | 	}
45 | 	if d&TUESDAYS != 0 {
46 | 		fmt.Print("* TUESDAY\n")
47 | 	}
48 | 	if d&WEDNESDAYS != 0 {
49 | 		fmt.Print("* WEDNESDAY\n")
50 | 	}
51 | 	if d&THURSDAYS != 0 {
52 | 		fmt.Print("* THURSDAY\n")
53 | 	}
54 | 	if d&FRIDAYS != 0 {
55 | 		fmt.Print("* FRIDAY\n")
56 | 	}
57 | 	if d&SATURDAYS != 0 {
58 | 		fmt.Print("* SATURDAY\n")
59 | 	}
60 | }
61 | 
62 | func main() {
63 | 	day()
64 | 
65 | 	days(34)
66 | 
67 | 	days(MONDAYS | FRIDAYS)
68 | 
69 | 	days(5)
70 | 
71 | 	days(127)
72 | }
73 | 


--------------------------------------------------------------------------------
/test/samples/go/cases/channels.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | func main() {
 8 | 	c1 := incrementor("Foo:")
 9 | 	c2 := incrementor("Bar:")
10 | 	c3 := puller(c1)
11 | 	c4 := puller(c2)
12 | 	fmt.Println("Final Counter:", <-c3+<-c4)
13 | }
14 | 
15 | func incrementor(s string) chan int {
16 | 	out := make(chan int)
17 | 	go func() {
18 | 		for i := 0; i < 20; i++ {
19 | 			out <- 1
20 | 			fmt.Println(s, i)
21 | 		}
22 | 		close(out)
23 | 	}()
24 | 	return out
25 | }
26 | 
27 | func puller(c chan int) chan int {
28 | 	out := make(chan int)
29 | 	go func() {
30 | 		var sum int
31 | 		for n := range c {
32 | 			sum += n
33 | 		}
34 | 		out <- sum
35 | 		close(out)
36 | 	}()
37 | 	return out
38 | }
39 | 


--------------------------------------------------------------------------------
/test/samples/go/cases/loop.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	for i := 0; i < 5; i++ {
 7 | 		for j := 0; j < 5; j++ {
 8 | 			fmt.Println(i, " - ", j)
 9 | 		}
10 | 	}
11 | }
12 | 


--------------------------------------------------------------------------------
/test/samples/go/cases/params.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"io"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | func myName(w http.ResponseWriter, req *http.Request) {
 9 | 	io.WriteString(w, "hello mcleod")
10 | }
11 | 
12 | func sum(vals ...int) int {
13 | 	total := 0
14 | 	for _, val := range vals {
15 | 		total += val
16 | 	}
17 | 	return total
18 | }
19 | 
20 | func filter(numbers []int, callback func(int) bool) []int {
21 | 	var xs []int
22 | 	for _, n := range numbers {
23 | 		if callback(n) {
24 | 			xs = append(xs, n)
25 | 		}
26 | 	}
27 | 	return xs
28 | }
29 | 
30 | // Toggle the `Done` attribute of a Todo.
31 | func Toggle(date string, tds Todos) {
32 | 	index := getIndex(date, tds)
33 | 	td := tds[index]
34 | 	td.toggle()
35 | }
36 | 
37 | // Drop a todo from Todos.
38 | // This is a poor way to go about this. Needs much improvement.
39 | func Drop(date string, tds Todos) Todos {
40 | 	var result Todos
41 | 	for _, v := range tds {
42 | 		if v.Date != date {
43 | 			result = append(result, v)
44 | 		}
45 | 	}
46 | 	return result
47 | }
48 | 


--------------------------------------------------------------------------------
/test/samples/go/cases/ping-pong.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | type Ball struct{ hits int }
 4 | 
 5 | func main() {
 6 | 	table := make(chan *Ball)
 7 | 	go player("ping", table)
 8 | 	go player("pong", table)
 9 | 
10 | 	table <- new(Ball) // game on; toss the ball
11 | 	time.Sleep(1 * time.Second)
12 | 	<-table // game over; grab the ball
13 | 
14 | 	panic("show me the stacks")
15 | }
16 | 
17 | func player(name string, table chan *Ball) {
18 | 	for {
19 | 		ball := <-table
20 | 		ball.hits++
21 | 		fmt.Println(name, ball.hits)
22 | 		time.Sleep(100 * time.Millisecond)
23 | 		table <- ball
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/test/samples/go/cases/receiver.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | type person struct {
 8 | 	Name string
 9 | 	Age  int
10 | }
11 | 
12 | type doubleZero struct {
13 | 	person
14 | 	LicenseToKill bool
15 | }
16 | 
17 | func (p person) Greeting() {
18 | 	fmt.Println("I'm just a regular person.")
19 | }
20 | 
21 | func (dz doubleZero) Greeting() {
22 | 	fmt.Println("Miss Moneypenny, so good to see you.")
23 | }
24 | 
25 | func main() {
26 | 	p1 := person{
27 | 		Name: "Ian Flemming",
28 | 		Age:  44,
29 | 	}
30 | 
31 | 	p2 := doubleZero{
32 | 		person: person{
33 | 			Name: "James Bond",
34 | 			Age:  23,
35 | 		},
36 | 		LicenseToKill: true,
37 | 	}
38 | 	p1.Greeting()
39 | 	p2.Greeting()
40 | 	p2.person.Greeting()
41 | }
42 | 


--------------------------------------------------------------------------------
/test/samples/go/channel.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | func main() {
 8 | 
 9 | 	c := make(chan int)
10 | 	done := make(chan bool)
11 | 
12 | 	go func() {
13 | 		for i := 0; i < 10; i-- {
14 | 			c <- i
15 | 		}
16 | 		done <- true
17 | 	}()
18 | 
19 | 	go func() {
20 | 		for i := 0; i < 10; i++ {
21 | 			c <- i
22 | 		}
23 | 		done <- true
24 | 	}()
25 | 
26 | 	go func() {
27 | 		<-done
28 | 		<-done
29 | 		close(c)
30 | 	}()
31 | 
32 | 	for n := range c {
33 | 		fmt.Println(n)
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/test/samples/go/gohtml/calhoun.io.gotmpl:
--------------------------------------------------------------------------------
 1 | {{.Title}}
 2 | {{.HTML}}
 3 | {{.SafeHTML}}
 4 | {{.}}
 5 | 
 6 | 
 7 | <a title="{{.Title}}">
 8 | <a title="{{.HTML}}">
 9 | 
10 | <a href="{{.HTML}}">
11 | <a href="?q={{.HTML}}">
12 | <a href="{{.Path}}">
13 | <a href="?q={{.Path}}">
14 | 
15 | <!-- Encoding even works on non-string values! -->
16 | <script>
17 |   var dog = {{.Dog}};
18 |   var map = {{.Map}};
19 |   doWork({{.Title}});
20 | </script>
21 | 


--------------------------------------------------------------------------------
/test/samples/go/gohtml/index.gohtml:
--------------------------------------------------------------------------------
 1 | {{define "header"}}
 2 | <!DOCTYPE html>
 3 | <html lang="en">
 4 | <head>
 5 |   <meta charset="UTF-8">
 6 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |   <title> {{ . }} </title>
 8 | </head>
 9 | <body>
10 | {{end}}
11 | 


--------------------------------------------------------------------------------
/test/samples/go/gohtml/sample.gohtml:
--------------------------------------------------------------------------------
 1 | 
 2 |   {{template "header" .Title}}
 3 | 
 4 |   <h1> All about us </h1>
 5 |   {{range .Members}}
 6 |   {{.}}<br/>
 7 |   {{end}}
 8 | 
 9 |   {{template "footer"}}
10 | 


--------------------------------------------------------------------------------
/test/samples/go/iota.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | const (
 6 | 	_  = iota             // 0
 7 | 	KB = 1 << (iota * 10) // 1 << (1 * 10)
 8 | 	MB = 1 << (iota * 10) // 1 << (2 * 10)
 9 | 	GB = 1 << (iota * 10) // 1 << (3 * 10)
10 | 	TB = 1 << (iota * 10) // 1 << (4 * 10)
11 | )
12 | 
13 | func main() {
14 | 	fmt.Println("binary\t\tdecimal")
15 | 	fmt.Printf("%b\t", KB)
16 | 	fmt.Printf("%d\n", KB)
17 | 	fmt.Printf("%b\t", MB)
18 | 	fmt.Printf("%d\n", MB)
19 | 	fmt.Printf("%b\t", GB)
20 | 	fmt.Printf("%d\n", GB)
21 | 	fmt.Printf("%b\t", TB)
22 | 	fmt.Printf("%d\n", TB)
23 | }
24 | 


--------------------------------------------------------------------------------
/test/samples/go/issues/00.go:
--------------------------------------------------------------------------------
 1 | func HandleError(w http.ResponseWriter, err error) {
 2 | 	if err != nil {
 3 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 4 | 		log.Fatalln(err)
 5 | 	}
 6 | }
 7 | 
 8 | package main
 9 | 
10 | import (
11 | 	"io"
12 | 	"net/http"
13 | )
14 | 
15 | func d(res http.ResponseWriter, req *http.Request) {
16 | 	io.WriteString(res, "dog dog dog")
17 | }
18 | 
19 | func c(res http.ResponseWriter, req *http.Request) {
20 | 	io.WriteString(res, "cat cat cat")
21 | }
22 | 
23 | func main() {
24 | 
25 | 	http.HandleFunc("/dog", d)
26 | 	http.HandleFunc("/cat", c)
27 | 
28 | 	http.ListenAndServe(":8080", nil)
29 | }
30 | 


--------------------------------------------------------------------------------
/test/samples/go/issues/01.go:
--------------------------------------------------------------------------------
 1 | import "mylib"
 2 | 
 3 | type myInt int
 4 | 
 5 | type myStruct struct {
 6 | 	aaa       // looks good
 7 | 	bbb myInt // "myInt" scoped as "source.go"
 8 | 	ccc []myInt
 9 | 	ddd map[myInt]int // "myInt" scoped as "source.go"
10 | 
11 | 	locks      *myLib.myRune
12 | 	globalLock myLib.myRune
13 | }
14 | 


--------------------------------------------------------------------------------
/test/samples/go/issues/02.go:
--------------------------------------------------------------------------------
 1 | type myInt int
 2 | 
 3 | type myStruct struct {
 4 | 	aaa map[myInt]myInt // "map" scoped as "keyword.map.go"
 5 | }
 6 | 
 7 | var m1 map[myInt]myInt     // "map" scoped as "entity.name.type.go"
 8 | var m2, m3 map[myInt]myInt // "map" scoped as "keyword.map.go"
 9 | 
10 | func foo(arg map[myInt]myInt) { // "map" scoped as "keyword.map.go"
11 | }
12 | 


--------------------------------------------------------------------------------
/test/samples/go/krypt.go:
--------------------------------------------------------------------------------
 1 | // In the following example we demonstrate how to encrypt data using AES in GCM mode:
 2 | package main
 3 | 
 4 | import (
 5 | 	"crypto/aes"
 6 | 	"crypto/cipher"
 7 | 	"crypto/rand"
 8 | 	"errors"
 9 | 	"fmt"
10 | 	"io"
11 | 	"log"
12 | )
13 | 
14 | func main() {
15 | 	text := []byte("My name is Astaxie")
16 | 	key := []byte("the-key-has-to-be-32-bytes-long!")
17 | 
18 | 	ciphertext, err := encrypt(text, key)
19 | 	if err != nil {
20 | 		// TODO: Properly handle error
21 | 		log.Fatal(err)
22 | 	}
23 | 	fmt.Printf("%s => %x\n", text, ciphertext)
24 | 
25 | 	plaintext, err := decrypt(ciphertext, key)
26 | 	if err != nil {
27 | 		// TODO: Properly handle error
28 | 		log.Fatal(err)
29 | 	}
30 | 	fmt.Printf("%x => %s\n", ciphertext, plaintext)
31 | }
32 | 
33 | func encrypt(plaintext []byte, key []byte) ([]byte, error) {
34 | 	c, err := aes.NewCipher(key)
35 | 	if err != nil {
36 | 		return nil, err
37 | 	}
38 | 
39 | 	gcm, err := cipher.NewGCM(c)
40 | 	if err != nil {
41 | 		return nil, err
42 | 	}
43 | 
44 | 	nonce := make([]byte, gcm.NonceSize())
45 | 	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
46 | 		return nil, err
47 | 	}
48 | 
49 | 	return gcm.Seal(nonce, nonce, plaintext, nil), nil
50 | }
51 | 
52 | func decrypt(ciphertext []byte, key []byte) ([]byte, error) {
53 | 	c, err := aes.NewCipher(key)
54 | 	if err != nil {
55 | 		return nil, err
56 | 	}
57 | 
58 | 	gcm, err := cipher.NewGCM(c)
59 | 	if err != nil {
60 | 		return nil, err
61 | 	}
62 | 
63 | 	nonceSize := gcm.NonceSize()
64 | 	if len(ciphertext) < nonceSize {
65 | 		return nil, errors.New("ciphertext too short")
66 | 	}
67 | 
68 | 	nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
69 | 	return gcm.Open(nil, nonce, ciphertext, nil)
70 | }
71 | 


--------------------------------------------------------------------------------
/test/samples/go/mutex.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"math/rand"
 6 | 	"sync"
 7 | 	"time"
 8 | )
 9 | 
10 | var wg sync.WaitGroup
11 | var counter int
12 | var mutex sync.Mutex
13 | 
14 | func main() {
15 | 	wg.Add(2)
16 | 	go incrementor("Foo:")
17 | 	go incrementor("Bar:")
18 | 	wg.Wait()
19 | 	fmt.Println("Final Counter:", counter)
20 | }
21 | 
22 | func incrementor(s string) {
23 | 	for i := 0; i < 20; i++ {
24 | 		time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
25 | 		mutex.Lock()
26 | 		counter++
27 | 		fmt.Println(s, i, "Counter:", counter)
28 | 		mutex.Unlock()
29 | 	}
30 | 	wg.Done()
31 | }
32 | 
33 | // go run -race main.go
34 | // vs
35 | // go run main.go
36 | 


--------------------------------------------------------------------------------
/test/samples/go/regex1.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"regexp"
 6 | )
 7 | 
 8 | var variable string
 9 | var strarray []string
10 | var r = regexp.MustCompile("[^\\s]+")
11 | 
12 | func main() {
13 | 	variable = "Lorem  Ipsum  Dolor   Sit  Amet"
14 | 	strarray = r.FindAllString(variable, -1)
15 | 	for i := 0; i < len(strarray); i++ {
16 | 		fmt.Println(strarray[i])
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/test/samples/go/regex2.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"regexp"
 6 | )
 7 | 
 8 | /*
 9 | Date and time expressed according to ISO 8601:
10 | Date:							2014-11-01
11 | Combined date and time in UTC:	2014-11-01T10:01:13+00:00
12 | 								2014-11-01T10:01:13Z
13 | Week:							2014-W44
14 | Date with week number:			2014-W44-6
15 | Ordinal date:					2014-305
16 | */
17 | 
18 | var input string
19 | var r = regexp.MustCompile("(?P<ISO8601>(?P<year>\\d{4})(\\-W((?P<week>\\d{1,2})\\-(?P<weekday>\\d)?)|\\-(?P<month>\\d{2})\\-(?P<day>\\d{2})(T(?P<hour>\\d{2}):(?P<min>\\d{2})(:(?P<sec>\\d{2})(\\+\\d{2}:\\d{2}Z?)?)?)?|\\-(?P<yearday>\\d{1,3})))")
20 | 
21 | var tpl = `my name is {{input}}`
22 | 
23 | func main() {
24 | 	input = `
25 | 2014-06-06
26 | 2014-11-01
27 | 2014-11-01T10:01:13+00:00
28 | 2014-11-01T10:01:13Z
29 | 2014-W44
30 | 2014-W44-6
31 | 2014-305
32 | 2014-23
33 | `
34 | 	match := r.FindAllString(input, -1)
35 | 	for i := 0; i < len(match); i++ {
36 | 		submatch := r.FindStringSubmatch(match[i])
37 | 		fmt.Printf("\nInput: %#v\n", match[i])
38 | 		for i, name := range r.SubexpNames() {
39 | 			if name != "" && submatch[i] != "" {
40 | 				fmt.Printf("\t%s\t %s\n", name, submatch[i])
41 | 			}
42 | 		}
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/test/samples/go/rune.go:
--------------------------------------------------------------------------------
 1 | /*Package main provides lines. */
 2 | package main
 3 | 
 4 | import (
 5 | 	"fmt"
 6 | 	"time"
 7 | )
 8 | 
 9 | func main() {
10 | 	fmt.Print(hide())
11 | 	fmt.Print(show())
12 | 
13 | }
14 | 
15 | func mySleepFunc() {
16 | 	//sleeps for 3 seconds
17 | 	time.Sleep(3 * time.Second)
18 | 	fmt.Println("My func out of sleep, but its executed concurrently\n")
19 | }
20 | 
21 | var esc = '\x1b'
22 | var return = "\u2318"
23 | 
24 | /* https://github.com/ahmetb/go-cursor/blob/master/cursor.go */
25 | 
26 | // Show returns ANSI escape sequence to show the cursor
27 | func show() string {
28 | 	// fmt.Print("%c%s", esc, fmt.Sprintf("[?25h"))
29 | 	return fmt.Sprintf("%c%s", '\x1b', fmt.Sprintf("[?25h"))
30 | }
31 | 
32 | // Hide returns ANSI escape sequence to hide the cursor
33 | func hide() string {
34 | 	return fmt.Sprintf("%c%s", '\x1b', fmt.Sprintf("[?25l"))
35 | }
36 | 


--------------------------------------------------------------------------------
/test/samples/go/template.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | _ = getGroups(`^snippet\s+(?P<trigger>\S+)\s(?P<description>".+")(?P<options>\s[biemrstwA]+$)?`, header)
 4 | 
 5 | _ = regexp.MustCompile(`(?P<input>\w+)(?P<sep>\:)(?P<output>\w+)`)
 6 | 
 7 | _ = regexp.MustCompile(`(?ms:(^\s+.+))`)
 8 | 
 9 | type Inventory struct {
10 | 	Material string
11 | 	Count    uint
12 | }
13 | sweaters := Inventory{"wool", 17}
14 | tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
15 | if err != nil { panic(err) }
16 | err = tmpl.Execute(os.Stdout, sweaters)
17 | if err != nil { panic(err) }
18 | 


--------------------------------------------------------------------------------
/test/samples/graphql/directives.gql:
--------------------------------------------------------------------------------
 1 | """Directs the executor to include this field or fragment only when the `if` argument is true."""
 2 | directive @include (
 3 |   "Included when true."
 4 |   if: Boolean!
 5 | ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 6 | 
 7 | """Directs the executor to skip this field or fragment when the `if` argument is true."""
 8 | directive @skip (
 9 |   "Skipped when true."
10 |   if: Boolean!
11 | ) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
12 | 
13 | """Marks an element of a GraphQL schema as no longer supported."""
14 | directive @deprecated(
15 |   """
16 |   Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data.
17 |   Formatted in [Markdown](https://daringfireball.net/projects/markdown/).
18 |   """
19 |   reason: String = "No longer supported"
20 | ) on FIELD_DEFINITION | ENUM_VALUE
21 | 
22 | """Marks an element of a GraphQL schema as having restricted access."""
23 | directive @accessRestricted (
24 |   reason: String = "No longer supported"
25 | ) on FIELD_DEFINITION | OBJECT
26 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/eex/index.html.eex:
--------------------------------------------------------------------------------
 1 | <div class="jumbotron">
 2 |   <h2><%= gettext "Welcome to %{name}!", name: "RSVP" %></h2>
 3 |   <p class="lead">A productive web framework that<br />does not compromise speed and maintainability.</p>
 4 | </div>
 5 | 
 6 | <div class="row marketing">
 7 |   <div class="col-lg-6">
 8 |     <h4>Resources</h4>
 9 |     <ul>
10 |       <li>
11 |         <a href="http://phoenixframework.org/docs/overview">Guides</a>
12 |       </li>
13 |       <li>
14 |         <a href="https://hexdocs.pm/phoenix">Docs</a>
15 |       </li>
16 |       <li>
17 |         <a href="https://github.com/phoenixframework/phoenix">Source</a>
18 |       </li>
19 |     </ul>
20 |   </div>
21 | 
22 |   <div class="col-lg-6">
23 |     <h4>Help</h4>
24 |     <ul>
25 |       <li>
26 |         <a href="http://groups.google.com/group/phoenix-talk">Mailing list</a>
27 |       </li>
28 |       <li>
29 |         <a href="http://webchat.freenode.net/?channels=elixir-lang">#elixir-lang on freenode IRC</a>
30 |       </li>
31 |       <li>
32 |         <a href="https://twitter.com/elixirphoenix">@elixirphoenix</a>
33 |       </li>
34 |     </ul>
35 |   </div>
36 | </div>
37 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/eex/sample.html.eex:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <meta name="description" content="">
 8 |     <meta name="author" content="">
 9 | 
10 |     <title>Hello Fawkes!</title>
11 |     <link rel="stylesheet" href="<%= static_path(@conn, "/css/app.css") %>">
12 |   </head>
13 | 
14 |   <body>
15 |     <div class="container">
16 |       <header class="header">
17 |         <nav role="navigation">
18 |           <ul class="nav nav-pills pull-right">
19 |             <li><a href="http://www.phoenixframework.org/docs">Get Started</a></li>
20 |           </ul>
21 |         </nav>
22 |         <span class="logo"></span>
23 |       </header>
24 | 
25 |       <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
26 |       <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
27 | 
28 |       <main role="main">
29 |         <%= render(@view_module, @view_template, assigns) %>
30 |       </main>
31 | 
32 |     </div> <!-- /container -->
33 |     <script src="<%= static_path(@conn, "/js/app.js") %>"></script>
34 |   </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/ejs/layout.ejs:
--------------------------------------------------------------------------------
1 | <html>
2 |     <body>
3 |         <%- include('includes/head'); %>
4 |         <%- content %>
5 |         <%- include('includes/foot', { year: year }); %>
6 |     </body>
7 | </html>
8 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/ejs/sample.ejs:
--------------------------------------------------------------------------------
 1 | <% if (user) { %>
 2 |   <h2><%= user.name %></h2>
 3 | <% } %>
 4 | 
 5 | <ul>
 6 |   <% users.forEach(function(user){ %>
 7 |     <% include user/show %>
 8 |   <% }) %>
 9 | </ul>
10 | 
11 | 
12 | <% include head %>
13 | <h1>Title</h1>
14 | <p>My page</p>
15 | <% include foot %>
16 | 
17 | <% include ../partials/nav %>
18 | <section name=”jumbotron” >
19 |  <div class=”jumbotron text-center”>
20 |  <h1>CodePrep.io Presents</h1>
21 |  <p>Using EJS templating with Node.js</p>
22 |  </div>
23 |  </section>
24 | <% include ../partials/3columns %>
25 | <% include ../partials/footer %>
26 | <% include ../partials/scripts %>
27 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/erb/sample.erb:
--------------------------------------------------------------------------------
 1 | <%# Non-printing tag ↓ -%>
 2 | <% if @keys_enable -%>
 3 | <%# Expression-printing tag ↓ -%>
 4 | keys <%= @keys_file %>
 5 | <% unless @keys_trusted.empty? -%>
 6 | trustedkey <%= @keys_trusted.join(' ') %>
 7 | <% end -%>
 8 | <% if @keys_requestkey != '' -%>
 9 | requestkey <%= @keys_requestkey %>
10 | <% end -%>
11 | <% if @keys_controlkey != '' -%>
12 | controlkey <%= @keys_controlkey %>
13 | <% end -%>
14 | 
15 | <% end -%>
16 | 
17 | <% for @item in @shopping_list %>
18 |   <%= @item %>
19 | <% end %>
20 | 
21 | 
22 | <%# Syntax error: %>
23 | <% @servers.each -%>
24 | # some server
25 | <% do |server| %>server <%= server %>
26 | <% end -%>
27 | 
28 | 


--------------------------------------------------------------------------------
/test/samples/html/embedded/erb/sample.html.erb:
--------------------------------------------------------------------------------
 1 | <h1>Listing Books</h1>
 2 | 
 3 | <table>
 4 |   <tr>
 5 |     <th>Title</th>
 6 |     <th>Summary</th>
 7 |     <th></th>
 8 |     <th></th>
 9 |     <th></th>
10 |   </tr>
11 | 
12 | <% @books.each do |book| %>
13 |   <tr>
14 |     <td><%= book.title %></td>
15 |     <td><%= book.content %></td>
16 |     <td><%= link_to "Show", book %></td>
17 |     <td><%= link_to "Edit", edit_book_path(book) %></td>
18 |     <td><%= link_to "Remove", book, method: :delete, data: { confirm: "Are you sure?" } %></td>
19 |   </tr>
20 | <% end %>
21 | </table>
22 | 
23 | <br>
24 | 
25 | <%= link_to "New book", new_book_path %>
26 | 


--------------------------------------------------------------------------------
/test/samples/html/html/html5-boilerplate.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html class="no-js" lang="">
 3 | 
 4 | <head>
 5 |   <meta charset="utf-8">
 6 |   <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |   <title></title>
 8 |   <meta name="description" content="">
 9 |   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
10 | 
11 |   <link rel="manifest" href="site.webmanifest">
12 |   <link rel="apple-touch-icon" href="icon.png">
13 |   <!-- Place favicon.ico in the root directory -->
14 | 
15 |   <link rel="stylesheet" href="css/normalize.css">
16 |   <link rel="stylesheet" href="css/main.css">
17 | </head>
18 | 
19 | <body>
20 |   <!--[if lte IE 9]>
21 |     <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="https://browsehappy.com/">upgrade your browser</a> to improve your experience and security.</p>
22 |   <![endif]-->
23 | 
24 |   <!-- Add your site or application content here -->
25 |   <p>Hello world! This is HTML5 Boilerplate.</p>
26 |   <script src="js/vendor/modernizr-3.6.0.min.js"></script>
27 |   <script src="https://code.jquery.com/jquery-3.3.1.min.js" integrity="sha256-FgpCb/KJQlLNfOu91ta32o/NMZxltwRo8QtmkMRdAu8=" crossorigin="anonymous"></script>
28 |   <script>window.jQuery || document.write('<script src="js/vendor/jquery-3.3.1.min.js"><\/script>')</script>
29 |   <script src="js/plugins.js"></script>
30 |   <script src="js/main.js"></script>
31 | 
32 |   <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
33 |   <script>
34 |     window.ga = function () { ga.q.push(arguments) }; ga.q = []; ga.l = +new Date;
35 |     ga('create', 'UA-XXXXX-Y', 'auto'); ga('send', 'pageview')
36 |   </script>
37 |   <script src="https://www.google-analytics.com/analytics.js" async defer></script>
38 | </body>
39 | 
40 | </html>
41 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/angular/app.component.html:
--------------------------------------------------------------------------------
 1 | <h2>My Heroes</h2>
 2 | 
 3 | <div *ngIf="selectedHero">
 4 |   <h2>{{selectedHero.name | uppercase}} Details</h2>
 5 |   <div><span>id: </span>{{selectedHero.id}}</div>
 6 |   <div>
 7 |     <label>name:
 8 |       <input [(ngModel)]="selectedHero.name" placeholder="name"/>
 9 |     </label>
10 |   </div>
11 | </div>
12 | 
13 | <ul class="heroes">
14 |   <li *ngFor="let hero of heroes"
15 |     [class.selected]="hero === selectedHero"
16 |     (click)="onSelect(hero)">
17 |     <span class="badge">{{hero.id}}</span> {{hero.name}}
18 |   </li>
19 | </ul>
20 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/angular/hero-detail.component.html:
--------------------------------------------------------------------------------
 1 | <div *ngIf="hero">
 2 |   <h2>{{hero.name | uppercase}} Details</h2>
 3 |   <div><span>id: </span>{{hero.id}}</div>
 4 |   <div>
 5 |     <label>name:
 6 |       <input [(ngModel)]="hero.name" placeholder="name"/>
 7 |     </label>
 8 |   </div>
 9 |   <button (click)="goBack()">go back</button>
10 |   <button (click)="save()">save</button>
11 | </div>
12 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/angular/hero-form.component.html:
--------------------------------------------------------------------------------
1 | <button (click)="onSave($event)">Save</button>
2 | <button *ngFor="let hero of heroes" (click)="deleteHero(hero)">{{hero.name}}</button>
3 | <form #heroForm (ngSubmit)="onSubmit(heroForm)"> ... </form>
4 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/angular/ng-for.component.html:
--------------------------------------------------------------------------------
 1 | <h2>My Heroes</h2>
 2 | 
 3 | <ul class="heroes">
 4 |   <li *ngFor="let hero of heroes" (click)="onSelect(hero)">
 5 |     <span class="badge">{{hero.id}}</span> {{hero.name}}
 6 |   </li>
 7 | </ul>
 8 | 
 9 | <!-- <li *ngFor="let user of userObservable | async as users; index as i; first as isFirst">
10 |   {{i}}/{{users.length}}. {{user}} <span *ngIf="isFirst">default</span>
11 | </li> -->
12 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/angular/star.component.html:
--------------------------------------------------------------------------------
 1 | <div class="crop"
 2 |      [style.width.px]="starWidth"
 3 |      [title]="rating"
 4 |      (click)="onClick()">
 5 |   <div style="width: 75px">
 6 |     <span class="fa fa-star"></span>
 7 |     <span class="fa fa-star"></span>
 8 |     <span class="fa fa-star"></span>
 9 |     <span class="fa fa-star"></span>
10 |     <span class="fa fa-star"></span>
11 |   </div>
12 | </div>


--------------------------------------------------------------------------------
/test/samples/html/misc/blade/loop.blade:
--------------------------------------------------------------------------------
 1 | @for ($i = 0; $i < 10; $i++)
 2 |     The current value is {{ $i }}
 3 | @endfor
 4 | 
 5 | @foreach ($users as $user)
 6 |     <p>This is user {{ $user->id }}</p>
 7 | @endforeach
 8 | 
 9 | @forelse ($users as $user)
10 |     <li>{{ $user->name }}</li>
11 | @empty
12 |     <p>No users</p>
13 | @endforelse
14 | 
15 | @while (true)
16 |     <p>I'm looping forever.</p>
17 | @endwhile
18 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/blade/sample.blade:
--------------------------------------------------------------------------------
 1 | <!-- Stored in resources/views/child.blade.php -->
 2 | 
 3 | @extends('layouts.app')
 4 | 
 5 | @section('title', 'Page Title')
 6 | 
 7 | @section('sidebar')
 8 |     @parent
 9 | 
10 |     <p>This is appended to the master sidebar.</p>
11 | @endsection
12 | 
13 | @section('content')
14 |     <p>This is my body content.</p>
15 | @endsection
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/haml/sample.haml:
--------------------------------------------------------------------------------
1 | .item{:id => "item#{item.id}"}= item.body
2 | 
3 | #content
4 |   .left.column
5 |     %h2 Welcome to our site!
6 |     %p= print_information
7 |   .right.column
8 |     = render :partial => "sidebar"
9 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/jinja/idk.jinja:
--------------------------------------------------------------------------------
 1 | <div class="control-group{{ invalid }}">
 2 |     <label for="{{ id }}" class="control-label">{{ label }}</label>
 3 |     <div class="controls">
 4 |         {% if type == "textarea" %}
 5 |         <textarea rows="5" name="{{ name }}[{{ property }}]">{{ attribute(model, property) }}</textarea>
 6 |         {% else %}
 7 |         <input type="{{ type }}" placeholder="{{ placeholder|default(property) }}" value="{{ attribute(model, property) }}" class="input-xlarge" id="{{ id }}" name="{{ name }}[{{ property }}]" />
 8 |         {% endif %}
 9 |         {% if invalid %}
10 |         <p class="help-block error">
11 |             {{ message }}
12 |         </p>
13 |         {% endif %}
14 |     </div>
15 | </div>
16 | {% endmacro %}
17 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/jinja/uno.jinja:
--------------------------------------------------------------------------------
 1 | {% extends "layout.html" %}
 2 | {% block body %}
 3 |   <ul>
 4 |   {% for user in users %}
 5 |     <li><a href="{{ user.url }}">{{ user.username }}</a></li>
 6 |   {% endfor %}
 7 |   </ul>
 8 | {% endblock %}
 9 | 
10 | <div>
11 |     {% if True %}
12 |         yay
13 |     {% endif %}
14 | </div>
15 | 
16 | <ul>
17 | {% for item in seq %}
18 |     <li>{{ item }}</li>
19 | {% endfor %}
20 | </ul>
21 | 
22 | {% extends "base.html" %}
23 | {% block title %}Index{% endblock %}
24 | {% block head %}
25 |     {{ super() }}
26 |     <style type="text/css">
27 |         .important { color: #336699; }
28 |     </style>
29 | {% endblock %}
30 | {% block content %}
31 |     <h1>Index</h1>
32 |     <p class="important">
33 |       Welcome to my awesome homepage.
34 |     </p>
35 | {% endblock %}
36 | 
37 | {% macro dump_users(users) -%}
38 |     <ul>
39 |     {%- for user in users %}
40 |         <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
41 |     {%- endfor %}
42 |     </ul>
43 | {%- endmacro %}
44 | 
45 | {% call(user) dump_users(list_of_user) %}
46 |     <dl>
47 |         <dl>Realname</dl>
48 |         <dd>{{ user.realname|e }}</dd>
49 |         <dl>Description</dl>
50 |         <dd>{{ user.description }}</dd>
51 |     </dl>
52 | {% endcall %}
53 | 
54 | {% from 'forms.html' import input as input_field, textarea %}
55 | <dl>
56 |     <dt>Username</dt>
57 |     <dd>{{ input_field('username') }}</dd>
58 |     <dt>Password</dt>
59 |     <dd>{{ input_field('password', type='password') }}</dd>
60 | </dl>
61 | <p>{{ textarea('comment') }}</p>
62 | 
63 | {% for item in list1 %}
64 | 
65 |     {{ item }}
66 |     {{ list2[loop.index0] }}
67 |     {{ list3[loop.index0] }}
68 | 
69 | {% endfor %}
70 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/sample.hbs:
--------------------------------------------------------------------------------
 1 | <div class="post">
 2 |   {{> userMessage tagName="h1" }}
 3 | 
 4 |   <h1>Comments</h1>
 5 | 
 6 |   {{#each comments}}
 7 |     {{> userMessage tagName="h2" }}
 8 |   {{/each}}
 9 | </div>
10 | 
11 | <div class="entry">
12 |   {{!-- only output author name if an author exists --}}
13 |   {{#if author}}
14 |     <h1>{{author.firstName}} {{author.lastName}}</h1>
15 |   {{/if}}
16 | </div>
17 | 
18 | <h1>Comments</h1>
19 | 
20 | <div id="comments">
21 |   {{#each comments}}
22 |   <h2><a href="/posts/{{../permalink}}#{{id}}">{{title}}</a></h2>
23 |   <div>{{body}}</div>
24 |   {{/each}}
25 | </div>
26 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/sample.vue.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title> Welcome to Vue </title>
 5 | </head>
 6 | <body>
 7 |   <div id="app">
 8 |     <img src="https://vuejs.org/images/logo.png" alt="Vue logo">
 9 |     <h1>{{ greeting }}</h1>
10 |     <ul>
11 |       <li>
12 |         To learn more about Vue, visit
13 |         <a v-bind:href="docsURL" target="_blank">
14 |           {{ humanizeURL(docsURL) }}
15 |         </a>
16 |       </li>
17 |       <li>
18 |         For live help with simple questions, check out
19 |         <a v-bind:href="gitterURL" target="_blank">
20 |           the Gitter chat
21 |         </a>
22 |       </li>
23 |       <li>
24 |         For more complex questions, post to
25 |         <a v-bind:href="forumURL" target="_blank">
26 |           the forum
27 |         </a>
28 |       </li>
29 |     </ul>
30 |   </div>
31 |   <script src="node_modules/steal/steal.js"></script>
32 | 
33 | </body>
34 | </html>
35 | 


--------------------------------------------------------------------------------
/test/samples/html/misc/slim/sample.slim:
--------------------------------------------------------------------------------
 1 | doctype html
 2 | html
 3 |   head
 4 |     title Slim Examples
 5 |     meta name="keywords" content="template language"
 6 |     meta name="author" content=author
 7 |     link rel="icon" type="image/png" href=file_path("favicon.png")
 8 |     javascript:
 9 |       alert('Slim supports embedded javascript!')
10 | 
11 |   body
12 |     h1 Markup examples
13 | 
14 |     #content
15 |       p This example shows you how a basic Slim file looks.
16 | 
17 |     == yield
18 | 
19 |     - if items.any?
20 |       table#items
21 |         - for item in items
22 |           tr
23 |             td.name = item.name
24 |             td.price = item.price
25 |     - else
26 |       p No items found. Please add some inventory.
27 |         Thank you!
28 | 
29 |     div id="footer"
30 |       == render 'footer'
31 |       | Copyright &copy; #{@year} #{@author}
32 | 


--------------------------------------------------------------------------------
/test/samples/java/Jenkinsfile:
--------------------------------------------------------------------------------
 1 | node {
 2 |     checkout scm
 3 | 
 4 |     try {
 5 |         stage 'Run unit/integration tests'
 6 |         sh 'make test'
 7 | 
 8 |         stage 'Build application artefacts'
 9 |         sh 'make build'
10 | 
11 |         stage 'Create release environment and run acceptance tests'
12 |         sh 'make release'
13 | 
14 |         stage 'Tag and publish release image'
15 |         sh "make tag latest \$(git rev-parse --short HEAD) \$(git tag --points-at HEAD)"
16 |         sh "make buildtag master \$(git tag --points-at HEAD)"
17 |         withEnv(["DOCKER_USER=${DOCKER_USER}",
18 |                  "DOCKER_PASSWORD=${DOCKER_PASSWORD}",
19 |                  "DOCKER_EMAIL=${DOCKER_EMAIL}"]) {
20 |             sh "make login"
21 |         }
22 |         sh "make publish"
23 | 
24 |         stage 'Deploy release'
25 |         sh "printf \$(git rev-parse --short HEAD) > tag.tmp"
26 |         def imageTag = readFile 'tag.tmp'
27 |         build job: DEPLOY_JOB, parameters: [[
28 |             $class: 'StringParameterValue',
29 |             name: 'IMAGE_TAG',
30 |             value: 'jmenga/todobackend:' + imageTag
31 |         ]]
32 |     }
33 |     finally {
34 |         stage 'Collect test reports'
35 |         step([$class: 'JUnitResultArchiver', testResults: '**/reports/*.xml'])
36 | 
37 |         stage 'Clean up'
38 |         sh 'make clean'
39 |         sh 'make logout'
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/test/samples/proto/scratch.proto:
--------------------------------------------------------------------------------
 1 | import "myproject/other_protos.proto";
 2 | 
 3 | import public "new.proto";
 4 | import "other.proto";
 5 | 
 6 | message Foo {
 7 |     reserved 2, 15, 9 to 11;
 8 |     reserved "foo", "bar";
 9 | }
10 | 
11 | message SearchRequest {
12 |     string query = 1;
13 |     int32 page_number = 2;
14 |     int32 result_per_page = 3;
15 |     enum Corpus {
16 |         UNIVERSAL = 0;
17 |         WEB = 1;
18 |         IMAGES = 2;
19 |         LOCAL = 3;
20 |         NEWS = 4;
21 |         PRODUCTS = 5;
22 |         VIDEO = 6;
23 |     }
24 |     Corpus corpus = 4;
25 | }
26 | 
27 | enum Foo {
28 |     reserved 2, 15, 9 to 11, 40 to max;
29 |     reserved "FOO", "BAR";
30 | }
31 | 
32 | message SearchResponse {
33 |     repeated Result results = 1;
34 | }
35 | 
36 | message Result {
37 |     string url = 1;
38 |     string title = 2;
39 |     repeated string snippets = 3;
40 | }
41 | 
42 | message SearchResponse {
43 |     message Result {
44 |         string url = 1;
45 |         string title = 2;
46 |         repeated string snippets = 3;
47 |     }
48 |     repeated Result results = 1;
49 | }
50 | 
51 | message SomeOtherMessage {
52 |     SearchResponse.Result result = 1;
53 | }
54 | 
55 | message ErrorStatus {
56 |     string message = 1;
57 |     repeated google.protobuf.Any details = 2;
58 | }
59 | 
60 | message SampleMessage {
61 |     oneof test_oneof {
62 |         string name = 4;
63 |         SubMessage sub_message = 9;
64 |     }
65 | }
66 | 
67 | package foo.bar;
68 | message Open {}
69 | 
70 | service FooService {
71 |     rpc GetSomething(GetSomethingRequest) returns (GetSomethingResponse);
72 |     rpc ListSomething(ListSomethingRequest) returns (ListSomethingResponse);
73 | }
74 | 


--------------------------------------------------------------------------------
/test/samples/python/call_count.py:
--------------------------------------------------------------------------------
 1 | class CallCount:
 2 |     def __init__(self, f):
 3 |         self.f = f
 4 |         self.count = 0
 5 | 
 6 |     def __call__(self, *args, **kwargs):
 7 |         self.count += 1
 8 |         return self.f(*args, **kwargs)
 9 | 
10 | 
11 | @CallCount
12 | def hello(name):
13 |     print('Hello, {}'.format(name))
14 | 
15 | 


--------------------------------------------------------------------------------
/test/samples/python/dict.py:
--------------------------------------------------------------------------------
 1 | from typing import Dict
 2 | 
 3 | class Student:
 4 | 
 5 |     def __init__(self, name: str, batch: int, branch: str, roll: int) -> None:
 6 |         self.name = name
 7 |         self.batch = batch
 8 |         self.branch = branch
 9 |         self.roll = roll
10 |         self.semester: str = None
11 |         self.papers: Dict[str, int] = {}
12 | 
13 |     def is_passed(self) -> bool:
14 |         "To find if the student has pass the exam in the current semester"
15 |         for k, v in self.papers.items():
16 |             if v < 34:
17 |                 return False
18 | 
19 |         return True
20 | 
21 | 
22 |     def total_score(self) -> int:
23 |         "Returns the total score of the student"
24 |         total = 0
25 |         for k, v in self.papers.items():
26 |             total += v
27 | 
28 |         return total
29 | 
30 | 
31 | std1: Student = Student("Kushal", 2005, "cse", 123)
32 | std2: Student = Student("Sayan", 2005, "cse", 121)
33 | std3: Student = Student("Anwesha", 2005, "law", 122)
34 | 
35 | std1.papers = {"english": 78, "math": 82, "science": 77}
36 | std2: Student.papers = {"english": 80, "math": 92, "science": 78}
37 | std3.papers = {"english": 82, "math": 87, "science": 77}
38 | 
39 | for std in [std1, std2, std3]:
40 |     print("Passed: {0}. The toral score of {1} is {2}".format(std.is_passed(), std.name, std.total_score()))
41 | 


--------------------------------------------------------------------------------
/test/samples/python/slice.py:
--------------------------------------------------------------------------------
 1 | """Model for aircraft flights."""
 2 | 
 3 | class Flight:
 4 | 
 5 |     def __init__(self, number):
 6 |         validate_number(number)
 7 |         self._number = number
 8 | 
 9 |     def number(self):
10 |         return self._number
11 | 
12 | 
13 | 
14 | def validate_number(number):
15 |     if not number[:2].isalpha():
16 |         raise ValueError(f"No airline code in {number}")
17 | 
18 |     if not number[:2].isupper():
19 |         raise ValueError(f"Invalid airline code {number}")
20 | 
21 |     if not (number[2:].isdigit() and int(number[2:]) <= 9999):
22 |         raise ValueError(f"Invalid route number {number}")
23 | 


--------------------------------------------------------------------------------
/test/samples/python/strangs.py:
--------------------------------------------------------------------------------
 1 | 
 2 | def main():
 3 |     try:
 4 |         "\x81" .decode('utf-8')
 5 |     except UnicodeError as e:
 6 |         print(e)
 7 |         print("encoding:", e.encoding)
 8 |         print("reason:", e.reason)
 9 |         print("object:", e.object)
10 |         print("start:", e.start)
11 |         print("end", e.end)
12 | 
13 | 
14 | if __name__ == '__main__':
15 |     main()
16 | 


--------------------------------------------------------------------------------
/test/samples/python/types.py:
--------------------------------------------------------------------------------
 1 | from typing import List, Tuple, Sequence, Optional
 2 | 
 3 | values: List[int] = []
 4 | city: int = 350 # The city code, not a name
 5 | 
 6 | 
 7 | # This function returns a Tuple of two values, a str and an int
 8 | def get_details() -> Tuple[str, int]:
 9 |     return "Python", 5
10 | 
11 | # The following is an example of Tuple unpacking
12 | name: str
13 | marks: int
14 | name, marks = get_details()
15 | 
16 | 
17 | def print_all(values: Sequence) -> None:
18 |     for v in values:
19 |         print(v)
20 | 
21 | 
22 | print_all([1,2,3])
23 | print_all({"name": "kushal", "class": 5})
24 | # alltypes.py:23: error: Argument 1 to "print_all" has incompatible type Dict[str, object]; expected Sequence[Any]
25 | # But running the code will give us no error with wrong output
26 | 
27 | def add_ten(number: Optional[int] = None) -> int:
28 |     if number:
29 |         return number + 10
30 |     else:
31 |         return 42
32 | 
33 | print(add_ten())
34 | print(add_ten(12))
35 | 


--------------------------------------------------------------------------------
/test/samples/ruby/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # Example 3
 2 | #
 3 | # Single box with VirtualBox provider and Puppet provisioning.
 4 | #
 5 | # NOTE: Make sure you have the precise32 base box installed...
 6 | # vagrant box add precise32 http://files.vagrantup.com/precise32.box
 7 | 
 8 | Vagrant.configure("2") do |config|
 9 |   config.vm.box = "precise32"
10 |   config.vm.hostname = "myprecise.box"
11 |   config.vm.network :private_network, ip: "192.168.0.42"
12 | 
13 |   config.vm.provider :virtualbox do |vb|
14 |     vb.customize [
15 |       "modifyvm", :id,
16 |       "--cpuexecutioncap", "50",
17 |       "--memory", "256",
18 |     ]
19 |   end
20 | 
21 |   config.vm.provision :puppet do |puppet|
22 |     puppet.manifests_path = "puppet/manifests"
23 |     puppet.manifest_file = "site.pp"
24 |     puppet.module_path = "puppet/modules"
25 |   end
26 | end
27 | 


--------------------------------------------------------------------------------
/test/samples/ruby/cucumber/example.feature:
--------------------------------------------------------------------------------
 1 | # Comment
 2 | @tag
 3 | Feature: Eating too many cucumbers may not be good for you
 4 | 
 5 |   Eating too much of anything may not be good for you.
 6 | 
 7 |   Scenario: Eating a few is no problem
 8 |     Given Alice is hungry
 9 |     When she eats 3 cucumbers
10 |     Then she will be full
11 | 


--------------------------------------------------------------------------------
/test/samples/ruby/cucumber/food.feature:
--------------------------------------------------------------------------------
 1 | Feature: Food
 2 |   In order to portray or pluralize food
 3 |   As a CLI
 4 |   I want to be as objective as possible
 5 | 
 6 |   Scenario: Broccoli is gross
 7 |     When I run `foodie portray broccoli`
 8 |     Then the output should contain "Gross!"
 9 | 
10 |   Scenario: Tomato, or Tomato?
11 |     When I run `foodie pluralize --word Tomato`
12 |     Then the output should contain "Tomatoes"
13 | 


--------------------------------------------------------------------------------
/test/samples/ruby/cucumber/is-it-friday-yet.feature:
--------------------------------------------------------------------------------
 1 | Feature: Is it Friday yet?
 2 |   Everybody wants to know when it's Friday
 3 | 
 4 |   Scenario Outline: Today is or is not Friday
 5 |     Given today is <day>
 6 |     When I ask whether it's Friday yet
 7 |     Then I should be told <answer>
 8 | 
 9 |   Examples:
10 |     |       day        | answer |
11 |     | "Friday"         | "TGIF" |
12 |     | "Sunday"         | "Nope" |
13 |     | "anything else!" | "Nope" |
14 | 


--------------------------------------------------------------------------------
/test/samples/ruby/goot/args.rb:
--------------------------------------------------------------------------------
 1 | # https://www.rubyguides.com/2018/06/rubys-method-arguments/
 2 | 
 3 | class Point
 4 |     def initialize(x: , y:)
 5 |         @x, @y = x, y
 6 |     end
 7 | end
 8 | point = Point.new(x: 10, y: 20)
 9 | 
10 | def print_all(*args); end
11 | print_all(1, 2, 3, 4, 5)
12 | 
13 | def testing(a, b = 1, *c, d: 1, **x)
14 |     puts(a, b, c, d, x)
15 | end
16 | testing('a', 'b', 'c', 'd', 'e', d: 2, x: 1)
17 | 
18 | def print_all(*); end
19 | 
20 | # https://blog.saeloun.com/2019/10/07/ruby-2-7-keyword-arguments-redesign.html
21 | 
22 | class C
23 |     def hi(needed, needed2,
24 |            maybe1 = "42", maybe2 = maybe1.upcase,
25 |            *args,
26 |            named1: 'hello', named2: a_method(named1, needed2),
27 |            **options,
28 |            &block)
29 |     end
30 | end
31 | 
32 | C.instance_method(:hi).parameters
33 | # => [ [:req, :needed], [:req, :needed2],
34 | #      [:opt, :maybe1], [:opt, :maybe2],
35 | #      [:rest, :args],
36 | #      [:key, :named1], [:key, :named2],
37 | #      [:keyrest, :options],
38 | #      [:block, :block] ]
39 | 


--------------------------------------------------------------------------------
/test/samples/ruby/goot/heredoc.rb:
--------------------------------------------------------------------------------
 1 | want = <<~GRAPHQL
 2 |     """Options for T-Shirt size."""
 3 |     enum Size {
 4 |         Small
 5 |         Medium
 6 |         Large
 7 |     }
 8 | GRAPHQL
 9 | 
10 | str = "Look ma! A string!"
11 | 


--------------------------------------------------------------------------------
/test/samples/ruby/goot/sample1.rb:
--------------------------------------------------------------------------------
 1 | # Using re's to break up a line.
 2 | print "Please enter a line: "
 3 | line = gets.chomp
 4 | 
 5 | res = [ ]
 6 | while res != ''
 7 |     # String leading blanks.
 8 |     line.sub!(/^\s*/, '')
 9 | 
10 |     break if line == ''
11 | 
12 |     # See what the leading is for next action.
13 |     if line[0].chr == '"' then
14 |         # Quoted.
15 |         line.sub!(/^"([^"]*)"/, '')
16 |         res.push($1)
17 |     elsif line.sub!(/^(\d+):(\S+)/, '')
18 |         # Repeated with n:
19 |         $1.to_i.times { res.push($2) }
20 |     else
21 |         # Just a word.
22 |         line.sub!(/^(\S+)/, '')
23 |         res.push($1)
24 |     end
25 | end
26 | 
27 | res.each { |x| print "  [", x, "]\n" }
28 | 


--------------------------------------------------------------------------------
/test/samples/ruby/goot/strings.rb:
--------------------------------------------------------------------------------
 1 | simple_string = "Hello World"           # looks good
 2 | interpolated_string = "Hello #{world}"  # looks good
 3 | escaped_string = "Hello \nWorld"        # looks good
 4 | regex_brace = %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] # looks good
 5 | regex_bracket = %r{railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack} # looks good
 6 | regex_paren = %r(railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack) # looks good
 7 | regex_string_2 = /[a-w&&[^c-g]z]/
 8 | 
 9 | def ip_address?(str)
10 |     # We use !! to convert the return value to a boolean
11 |     !!(str =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)
12 | end
13 | 


--------------------------------------------------------------------------------
/test/samples/ruby/lambdas.rb:
--------------------------------------------------------------------------------
 1 | 
 2 | # No Space
 3 | l = ->name { puts "Hi #{name}!" }
 4 | 
 5 | # 1 Arg
 6 | l = -> one { ... }
 7 | 
 8 | # 2 Args
 9 | l = -> one, two { ... }
10 | 
11 | # 3 Args
12 | l = -> one, two, three { ... }
13 | 
14 | # 4 Args
15 | l = -> one, two, three, four { ... }
16 | 
17 | 


--------------------------------------------------------------------------------
/test/samples/ruby/regex.rb:
--------------------------------------------------------------------------------
1 | UUID_PATTERN_1 = %r(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}).freeze()
2 | UUID_PATTERN_2 = %r{/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}}.freeze()
3 | UUID_PATTERN_3 = %r[/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}].freeze()
4 | 


--------------------------------------------------------------------------------
/test/samples/ruby/sample2.rb:
--------------------------------------------------------------------------------
 1 | require("csim")
 2 | 
 3 | S = SwitchBank.new
 4 | A = AndGate.new
 5 | #A.join(Tester.new("A"))
 6 | B = OrGate.new
 7 | #B.join(Tester.new("B"))
 8 | C = AndGate.new
 9 | #C.join(Tester.new("C"))
10 | D = OrGate.new
11 | #D.join(Tester.new("D"))
12 | E = NotGate.new
13 | L = LED.new('Result')
14 | 
15 | A.join(D)
16 | B.join(D)
17 | C.join(D)
18 | D.join(E)
19 | D.join(A)
20 | D.join(C)
21 | 
22 | S.join(A)
23 | S.join(B)
24 | S.join(B)
25 | S.join(C)
26 | 
27 | E.join(L)
28 | 
29 | for x in (0..15)
30 |   for s in [3,2,1,0]
31 |     print (x>>s) & 1
32 |   end
33 |   print " => "
34 |   S.value = x
35 | end
36 | 
37 | require "csim"
38 | require "cgrp"
39 | 
40 | class OBA < Blueprint
41 |   def initialize
42 |     super("one-bit adder")
43 | 
44 |     # Get the parts.
45 |     a,b,cin = Connector.many(3)
46 |     gA = XorGate.new
47 |     gB,gC,gD = AndGate.many(3)
48 |     gE = OrGate.new
49 | 
50 |     # Hook 'em up.
51 |     a.joinmany(gA,gB,gC)
52 |     b.joinmany(gA,gB,gD)
53 |     cin.joinmany(gA,gC,gD)
54 |     [gB,gC,gD].each { |g| g.join(gE) }
55 | 
56 |     # Put it into a box.
57 |     self.inputs(a,b,cin)
58 |     self.outputs(gA, gE)
59 |     self.lock
60 |   end
61 | 
62 |   # @return [String]
63 |   def to_s()
64 |     type = pull_request ? "pull request" : "issue"
65 |     return "#{repo} - #{type} ##{number} - #{title}"
66 |   end
67 | 
68 | end
69 | 


--------------------------------------------------------------------------------
/test/samples/rust/alpha.rs:
--------------------------------------------------------------------------------
1 | /// Prints the letters of the Alphabet.
2 | pub fn the_alphabet() {
3 |     let ascii_iter = (0..26).map(|x| (x + 'a' as u8) as char);
4 | 
5 |     println!("{:?}", ascii_iter.collect::<Vec<_>>());
6 | }
7 | 


--------------------------------------------------------------------------------
/test/samples/rust/hashmap.rs:
--------------------------------------------------------------------------------
 1 | use std::collections::HashMap;
 2 | 
 3 | fn main() {
 4 |     let mut scores = HashMap::new();
 5 | 
 6 |     scores.insert(String::from("Blue"), 10);
 7 |     scores.insert(String::from("Yellow"), 50);
 8 | 
 9 |     let teams = vec![String::from("Blue"), String::from("Yellow")];
10 |     let initial_scores = vec![10, 50];
11 | 
12 |     // The type annotation HashMap<_, _> is needed here because it’s possible to collect into many different data structures and Rust doesn’t know which you want unless you specify.
13 |     let _scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();
14 | 
15 |     let mut scores = HashMap::new();
16 | 
17 |     scores.insert(String::from("Blue"), 10);
18 |     scores.insert(String::from("Yellow"), 50);
19 | 
20 |     for (key, value) in &scores {
21 |         println!("{}: {}", key, value);
22 |     }
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/test/samples/rust/hello.rs:
--------------------------------------------------------------------------------
 1 | use std::mem;
 2 | 
 3 | fn main() {
 4 |     // unsigned 0..255
 5 |     let a: u8 = 123; // 8 bits
 6 |     println!("a = {}", a);
 7 | 
 8 |     // mut
 9 |     let mut b: i8 = 0; // mutable
10 |     println!("b = {}", b);
11 |     b = 42;
12 |     println!("b = {}", b);
13 | 
14 |     let mut c = 123456789; // 32-bit signed i32
15 |     println!("c = {}, size = {} bytes", c, mem::size_of_val(&c));
16 | }
17 | 


--------------------------------------------------------------------------------
/test/samples/rust/impl.rs:
--------------------------------------------------------------------------------
 1 | pub trait Summary {
 2 |     fn summarize_author(&self) -> String;
 3 | 
 4 |     fn summarize(&self) -> String {
 5 |         format!("(Read more from {}...)", self.summarize_author())
 6 |     }
 7 | }
 8 | 
 9 | 
10 | pub struct NewsArticle {
11 |     pub headline: String,
12 |     pub location: String,
13 |     pub author: String,
14 |     pub content: String,
15 | }
16 | 
17 | impl Summary {
18 |     fn summarize(&self) -> String {
19 |         format!("{}, by {} ({})", self.headline, self.author, self.location)
20 |     }
21 | }
22 | 
23 | pub struct Tweet {
24 |     pub username: String,
25 |     pub content: String,
26 |     pub reply: bool,
27 |     pub retweet: bool,
28 | }
29 | 
30 | impl Summary for Tweet {
31 |     fn summarize_author(&self) -> String {
32 |         format!("@{}", self.username)
33 |     }
34 | }
35 | 
36 | fn main() {
37 |     let tweet = Tweet {
38 |         username: String::from("horse_ebooks"),
39 |         content:  String::from("of course, as you probably already know, people"),
40 |         reply:    false,
41 |         retweet:  false,
42 |     };
43 | 
44 |     let article = NewsArticle {
45 |         headline: String::from("Penguins win the Stanley Cup Championship!"),
46 |         location: String::from("Pittsburgh, PA, USA"),
47 |         author:   String::from("Iceburgh"),
48 |         content:  String::from("The Pittsburgh Penguins once again are the best hockey team in the NHL."),
49 |     };
50 | 
51 |     println!("1 new tweet: {}", tweet.summarize());
52 | 
53 |     println!("New article available! {}", article.summarize());
54 | }
55 | 


--------------------------------------------------------------------------------
/test/samples/rust/lifetime.rs:
--------------------------------------------------------------------------------
 1 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
 2 |     if x.len() > y.len() {
 3 |         x
 4 |     } else {
 5 |         y
 6 |     }
 7 | }
 8 | 
 9 | 
10 | fn main() {
11 |     let string1 = String::from("abcd");
12 |     let string2 = "xyz";
13 | 
14 |     let result = longest(string1.as_str(), string2);
15 |     println!("The longest string is {}", result);
16 | }
17 | 


--------------------------------------------------------------------------------
/test/samples/rust/loop.rs:
--------------------------------------------------------------------------------
 1 | fn main() {
 2 |     loop {
 3 |         match guess.cmp(&secret_number) {
 4 |             Ordering::Less => println!("Too small!"),
 5 |             Ordering::Greater => println!("Too big!"),
 6 |             Ordering::Equal => {
 7 |                 println!("You win!");
 8 |                 break;
 9 |             }
10 |         }
11 |     }
12 | 
13 |     let result = loop {
14 |         counter += 1;
15 | 
16 |         if counter == 10 {
17 |             break counter * 2;
18 |         }
19 |     };
20 | 
21 |     assert_eq!(result, 20);
22 | }
23 | 


--------------------------------------------------------------------------------
/test/samples/rust/method.rs:
--------------------------------------------------------------------------------
 1 | struct Circle {
 2 |     x: f64,
 3 |     y: f64,
 4 |     radius: f64,
 5 | }
 6 | 
 7 | impl Circle {
 8 |     fn area(&self) -> f64 {
 9 |         std::f64::consts::PI * (self.radius * self.radius)
10 |     }
11 | }
12 | 
13 | fn main() {
14 |     let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
15 |     println!("{}", c.area());
16 | }
17 | 


--------------------------------------------------------------------------------
/test/samples/rust/minigrep/main.rs:
--------------------------------------------------------------------------------
 1 | extern crate minigrep;
 2 | use minigrep::Config;
 3 | 
 4 | extern crate ansi_term;
 5 | use ansi_term::Color::Red;
 6 | 
 7 | use std::env;
 8 | use std::process;
 9 | 
10 | fn main() {
11 |     let args: Vec<String> = env::args().collect();
12 | 
13 |     let config = Config::new(&args).unwrap_or_else(|err| {
14 |         println!("Problem parsing arguments: {}", Red.paint(err).to_string());
15 |         process::exit(1);
16 |     });
17 | 
18 |     if let Err(err) = minigrep::run(config) {
19 |         println!("Application error: {}", Red.paint(err.to_string()));
20 |         process::exit(1);
21 |     }
22 | 
23 | }
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/test/samples/rust/namespace.rs:
--------------------------------------------------------------------------------
 1 | //! This is documentation for the `foo` crate.
 2 | //!
 3 | //! The foo crate is meant to be used for bar.
 4 | 
 5 | 
 6 | 
 7 | extern crate communicator;
 8 | 
 9 | fn main() {
10 |     communicator::client::connect();
11 | }
12 | 
13 | 
14 | /// uno contains example *1*
15 | pub mod uno;
16 | mod english;
17 | mod japanese;
18 | pub mod pig_latin;
19 | 
20 | // Module names follow the conventions for other Rust identifiers: lower_snake_case.
21 | mod english {
22 |     mod greetings {
23 |         fn hello() -> String {
24 |             "Hello!".to_string()
25 |         }
26 |     }
27 |     mod farewells {
28 |         fn goodbye() -> String {
29 |             "Goodbye.".to_string()
30 |         }
31 |     }
32 | }
33 | 
34 | mod japanese {
35 |     mod greetings {
36 |         fn hello() -> String {
37 |             "こんにちは".to_string()
38 |         }
39 |     }
40 |     mod farewells {
41 |         fn goodbye() -> String {
42 |             "さようなら".to_string()
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/test/samples/rust/num_func.rs:
--------------------------------------------------------------------------------
 1 | fn largest_i32(list: &[i32]) -> i32 {
 2 | 
 3 |     let mut largest = list[0];
 4 | 
 5 |     for &item in list.iter() {
 6 |         if item > largest {
 7 |             largest = item;
 8 |         }
 9 |     }
10 | 
11 |     largest
12 | }
13 | 
14 | fn largest_char(list: &[char]) -> char {
15 |     let mut largest = list[0];
16 | 
17 |     for &item in list.iter() {
18 |         if item > largest {
19 |             largest = item;
20 |         }
21 |     }
22 | 
23 |     largest
24 | }
25 | 
26 | /// OHHH *shit* boi
27 | /// looky hya
28 | /// ## BOOYAKASHA
29 | /// now that `shit` is **TIGHT**
30 | /// lol [Generic Types, Traits, and Lifetimes](https://doc.rust-lang.org/book/second-edition/ch10-00-generics.html#generic-types-traits-and-lifetimes)
31 | fn main() {
32 |     let number_list = vec![34, 50, 25, 100, 65];
33 | 
34 |     let result = largest_i32(&number_list);
35 |     println!("The largest number is {}", result);
36 | 
37 |     let char_list = vec!['y', 'm', 'a', 'q'];
38 | 
39 |     let result = largest_char(&char_list);
40 |     println!("The largest char is {}", result);
41 | }
42 | 


--------------------------------------------------------------------------------
/test/samples/rust/struccs.rs:
--------------------------------------------------------------------------------
 1 | use std::error::Error;
 2 | use std::fs::File;
 3 | use std::io::prelude::*;
 4 | // use std::string::ToString;
 5 | extern crate ansi_term;
 6 | use ansi_term::Color::Blue;
 7 | 
 8 | pub struct Config {
 9 |     pub query: String,
10 |     pub filename: String,
11 | }
12 | 
13 | impl Config {
14 |     pub fn new(args: &[String]) -> Result<Config, &'static str> {
15 |         if args.len() < 3 {
16 |             return Err("not enough arguments");
17 |         }
18 | 
19 |         let query = args[1].clone();
20 |         let filename = args[2].clone();
21 | 
22 |         Ok(Config { query, filename })
23 |     }
24 | }
25 | 
26 | pub fn run(config: Config) -> Result<(), Box<Error>> {
27 |     let mut f = File::open(config.filename)?;
28 | 
29 |     let mut contents = String::new();
30 |     f.read_to_string(&mut contents)?;
31 | 
32 |     println!("With text:\n{}", Blue.paint(contents.to_string()));
33 |     // println!("With text:\n{}", contents);
34 | 
35 |     Ok(())
36 | }
37 | 
38 | pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
39 |     let mut results = Vec::new();
40 | 
41 |     for line in contents.lines() {
42 |         if line.contains(query) {
43 |             results.push(line);
44 |         }
45 |     }
46 | 
47 |     results
48 | }
49 | 
50 | #[cfg(test)]
51 | mod test {
52 |     use super::*;
53 | 
54 |     #[test]
55 |     fn one_result() {
56 |         let query = "duct";
57 |         let contents = "\
58 | Rust:
59 | safe, fast, productive.
60 | Pick three.";
61 | 
62 |         assert_eq!(
63 |             vec!["safe, fast, productive."],
64 |             search(query, contents)
65 |         );
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/test/samples/rust/types.rs:
--------------------------------------------------------------------------------
1 | let strang = "Hello!";
2 | 
3 | let Char = 'π';
4 | 


--------------------------------------------------------------------------------
/test/samples/rust/wasm.rs:
--------------------------------------------------------------------------------
1 | #[no_mangle]
2 | pub extern fn add_one(a: u32) -> u32 {
3 |     a + 1
4 | }
5 | 


--------------------------------------------------------------------------------
/test/samples/shell/bash/.bash_profile:
--------------------------------------------------------------------------------
1 | echo "🏃 .bash_profile"
2 | [ -n "$PS1" ] && source ~ /.bashrc;
3 | 
4 | for file in ~/.{path,bash_prompt,exports,aliases,functions,extra}; do
5 | 	[ -r "$file" ] && [ -f "$file" ] && source "$file";
6 | done;
7 | unset file;
8 | 


--------------------------------------------------------------------------------
/test/samples/shell/bash/fzf.bash:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Setup fzf
 4 | # ---------
 5 | if [[ ! "$PATH" == */usr/local/opt/fzf/bin* ]]; then
 6 |   export PATH="$PATH:/usr/local/opt/fzf/bin"
 7 | fi
 8 | 
 9 | # Auto-completion
10 | # ---------------
11 | [[ $- == *i* ]] && source "/usr/local/opt/fzf/shell/completion.bash" 2> /dev/null
12 | 
13 | # Key bindings
14 | # ------------
15 | source "/usr/local/opt/fzf/shell/key-bindings.bash"
16 | 
17 | 
18 | # fd - cd to selected directory
19 | function fd() {
20 |   local dir
21 |   dir=$(find ${1:-.} -path '*/\.*' -prune \
22 |                   -o -type d -print 2> /dev/null | fzf +m) &&
23 |   cd "$dir"
24 | }
25 | 


--------------------------------------------------------------------------------
/test/samples/shell/zsh/.fzf.zsh:
--------------------------------------------------------------------------------
 1 | # Setup fzf
 2 | # ---------
 3 | if [[ ! "$PATH" == */usr/local/opt/fzf/bin* ]]; then
 4 |   export PATH="$PATH:/usr/local/opt/fzf/bin"
 5 | fi
 6 | 
 7 | # Auto-completion
 8 | # ---------------
 9 | [[ $- == *i* ]] && source "/usr/local/opt/fzf/shell/completion.zsh" 2> /dev/null
10 | 
11 | # Key bindings
12 | # ------------
13 | source "/usr/local/opt/fzf/shell/key-bindings.zsh"
14 | 
15 | 
16 | # fd - cd to selected directory
17 | function fd() {
18 |   local dir
19 |   dir=$(find ${1:-.} -path '*/\.*' -prune \
20 |                   -o -type d -print 2> /dev/null | fzf +m) &&
21 |   cd "$dir"
22 | }
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/test/samples/swift/Row.swift:
--------------------------------------------------------------------------------
 1 | func verbYourNoun(verb: String, noun: String) {
 2 |     print("\(verb), \(verb), \(verb) your \(noun)")
 3 |     print("something, something, something...")
 4 | }
 5 | 
 6 | func adverbly(adverb: String) {
 7 |     print("\(adverb), \(adverb), \(adverb)")
 8 |     print("something, something, something...\n")
 9 | }
10 | 
11 | /* verbYourNoun(verb: "row", noun: "boat") */
12 | // adverbly(adverb: "merrily")
13 | 
14 | func singSong(theVerb: String, theNoun: String, theAdverb: String) {
15 |     verbYourNoun(verb: theVerb, noun: theNoun)
16 |     adverbly(adverb: theAdverb)
17 | }
18 | 
19 | singSong(theVerb: "row", theNoun: "boat", theAdverb: "merrily")
20 | 


--------------------------------------------------------------------------------
/test/samples/swift/correct/override.swift:
--------------------------------------------------------------------------------
 1 | class Vehicle {
 2 |     var currentSpeed = 0.0
 3 |     var description: String {
 4 |         return "traveling at \(currentSpeed) miles per hour"
 5 |     }
 6 |     func makeNoise() {
 7 |         // do nothing - an arbitrary vehicle doesn't necessarily make a noise
 8 |     }
 9 | }
10 | 
11 | class Train: Vehicle {
12 |     override func makeNoise() {
13 |         print("Choo Choo")
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/samples/swift/operators.swift:
--------------------------------------------------------------------------------
 1 | //: Playground - noun: a place where people can play
 2 | 
 3 | import Cocoa
 4 | import Foundation
 5 | 
 6 | if let homePath = ProcessInfo.processInfo.environment["HOME"] {
 7 |     let completePath = homePath + "/Projects/Swift"
 8 |     print(completePath)
 9 | }
10 | 
11 | // var str = "Hello, playground"
12 | 
13 | 
14 | 


--------------------------------------------------------------------------------
/test/samples/viml/javascript-node.snippets:
--------------------------------------------------------------------------------
 1 | priority -50
 2 | 
 3 | snippet #! "shebang"
 4 | #!/usr/bin/env node
 5 | endsnippet
 6 | 
 7 | snippet vreq "assign a CommonJS-style module to a var"
 8 | var ${0:${1/(.+\/)*(\w+)(-|\b|$)(\..+$)?/\u$2/g}} = require('$1');
 9 | endsnippet
10 | 
11 | snippet ex "module.exports"
12 | module.exports = $1;
13 | endsnippet
14 | 
15 | snippet hcs "http.createServer"
16 | http.createServer($1).listen($2);
17 | endsnippet
18 | 
19 | snippet ncs "net.createServer"
20 | net.createServer(function(${1:socket}){
21 | 	$1.on('data', function(${3:data}){
22 | 		$4
23 | 	});
24 | 	$1.on('end', function(){
25 | 		$5
26 | 	});
27 | }).listen(${6:8124});
28 | endsnippet
29 | 
30 | snippet pipe "pipe"
31 | pipe(${1:stream})$2
32 | endsnippet
33 | 
34 | # Express snippets
35 | 
36 | snippet eget "express GET"
37 | ${1:app}.get('$2', $3);
38 | endsnippet
39 | 
40 | snippet epost "express POST"
41 | ${1:app}.post('$2', $3);
42 | endsnippet
43 | 
44 | snippet eput "express PUT"
45 | ${1:app}.put('$2', $3);
46 | endsnippet
47 | 
48 | snippet edelete "express DELETE"
49 | ${1:app}.delete('$2', $3);
50 | endsnippet
51 | 
52 | # process snippets
53 | 
54 | snippet stdout "stdout"
55 | process.stdout
56 | endsnippet
57 | 
58 | snippet stdin "stdin"
59 | process.stdin
60 | endsnippet
61 | 
62 | snippet stderr "stderr"
63 | process.stderr
64 | endsnippet
65 | 
66 | 


--------------------------------------------------------------------------------
/test/samples/viml/json.snippets:
--------------------------------------------------------------------------------
 1 | priority -50
 2 | 
 3 | snippet pair "Key:Value,"
 4 | "${1:value_name}": "${3:value}"${2:,}$0
 5 | endsnippet
 6 | 
 7 | snippet object "Key:{Object},"
 8 | "${1:value_name}": {$0}${2:,}
 9 | endsnippet
10 | 
11 | snippet array "Key:[ Object ],"
12 | "${1:value_name}": [$0]${2:,}
13 | endsnippet
14 | 
15 | snippet nest "nested tabstops"
16 | ${2: this a ${1:ne${3:r23r}sted} tabstop } $0
17 | endsnippet
18 | 
19 | # vim:ft=snippets:
20 | 


--------------------------------------------------------------------------------
/test/samples/viml/test.vim:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tcd/dark-plus-syntax/944c366ba68d8b2a806ebd16495e3653a646ced7/test/samples/viml/test.vim


--------------------------------------------------------------------------------
/test/samples/xml/menu.xml:
--------------------------------------------------------------------------------
 1 | <breakfast_menu>
 2 |     <food>
 3 |         <name>Belgian Waffles</name>
 4 |         <price>$5.95</price>
 5 |         <description>Two of our famous Belgian Waffles with plenty
 6 |         of real maple syrup</description>
 7 |         <calories>650</calories>
 8 |     </food>
 9 |     <food>
10 |         <name>Strawberry Belgian Waffles</name>
11 |         <price>$7.95</price>
12 |         <description>Light Belgian waffles covered with
13 |         strawberries and whipped cream</description>
14 |         <calories>900</calories>
15 |     </food>
16 |     <food>
17 |         <name>Berry-Berry Belgian Waffles</name>
18 |         <price>$8.95</price>
19 |         <description>Light Belgian waffles covered with an
20 |         assortment of fresh berries and whipped cream</description>
21 |         <calories>900</calories>
22 |     </food>
23 |     <food>
24 |         <name>French Toast</name>
25 |         <price>$4.50</price>
26 |         <description>Thick slices made from our homemade sourdough
27 |         bread</description>
28 |         <calories>600</calories>
29 |     </food>
30 |     <food>
31 |         <name>Homestyle Breakfast</name>
32 |         <price>$6.95</price>
33 |         <description>Two eggs, bacon or sausage, toast, and our
34 |         ever-popular hash browns</description>
35 |         <calories>950</calories>
36 |     </food>
37 | </breakfast_menu>
38 | 


--------------------------------------------------------------------------------
/test/samples/yaml/database.yml:
--------------------------------------------------------------------------------
 1 | # SQLite. Versions 3.8.0 and up are supported.
 2 | #   gem install sqlite3
 3 | #
 4 | #   Ensure the SQLite 3 gem is defined in your Gemfile
 5 | #   gem 'sqlite3'
 6 | #
 7 | default: &default
 8 |   adapter: sqlite3
 9 |   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
10 |   timeout: 5000
11 | 
12 | development:
13 |   <<: *default
14 |   database: db/development.sqlite3
15 | 
16 | # Warning: The database defined as "test" will be erased and
17 | # re-generated from your development database when you run "rake".
18 | # Do not set this db to the same as development or production.
19 | test:
20 |   <<: *default
21 |   database: db/test.sqlite3
22 | 
23 | production:
24 |   <<: *default
25 |   database: db/production.sqlite3
26 | 


--------------------------------------------------------------------------------
/test/samples/yaml/directive.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Directive
 3 | description: |
 4 |   Data for a [GraphQL directive](https://graphql.github.io/graphql-spec/draft/#sec-Language.Directives).
 5 | 
 6 |   See the [GraphQL spec](https://graphql.github.io/graphql-spec/draft/#sec-Type-System.Directives) or [Apollo's docs](https://www.apollographql.com/docs/graphql-tools/schema-directives/) for reference.
 7 | attrs:
 8 | - name: name
 9 |   type: String
10 |   read_only: true
11 | - name: description
12 |   type: String,nil
13 | - name: locations
14 |   description: Objects on which the directive can be used.
15 |   type: Array<String>
16 | - name: args
17 |   type: Array<Gql::Models::Argument>
18 | 


--------------------------------------------------------------------------------
/test/samples/yaml/oo.yml:
--------------------------------------------------------------------------------
 1 | server_defaults: &server_defaults
 2 |   ip: 192.168.1.5
 3 |   port: 2000
 4 | 
 5 | user_defaults: &user_defaults
 6 |   name: root
 7 |   password: root
 8 | 
 9 | database: &default
10 |   server:
11 |     <<: *server_defaults
12 |   db_name: test
13 |   user:
14 |     <<: *user_defaults
15 | 
16 | foo_database:
17 |   <<: *default
18 |   server:
19 |     <<: *server_defaults
20 |     port: 2001
21 |   db_name: foo
22 |   user:
23 |     <<: *user_defaults
24 |     password: foo_root
25 | 


--------------------------------------------------------------------------------
/test/samples/yaml/preview.yml:
--------------------------------------------------------------------------------
 1 | %YAML 1.2
 2 | %TAG !e! tag:example.com,2000:app/ # comment
 3 | %RESERVED name parameter #comment
 4 | ---
 5 | # https://github.com/sublimehq/Packages/blob/master/YAML/preview.yaml
 6 | - [~, null, Null, NULL, nUll,
 7 |    yes, no, true, false,
 8 |    0b0, +0b1_0_1, -0b1, ~, 0b, 0b2,
 9 |    01, +0_761, -07, ~, 09,
10 |    0, +1, -12_345,
11 |    0x0, +0x12_34_56, -0xabcdef, ~, 0xyz, 0x,
12 |    1:20, +1:9, -1_234:59:00, ~, 1:60, :60,
13 |    0.1, +.293, -1_123.e-3, 2.234.567,
14 |    .inf, +.INF, -.Inf, .nan, ~, .inF,
15 |    .NaN, ~, .Nan,
16 |    2015-08-15, 2015-08-15 1:20:30.123, 2015-08-15T12:20:30.123-9:00,
17 |    plain scalar, 'single-quoted ('''') scalar', "double-quoted (\"\") scalar"
18 |   ]
19 | 
20 | - &anchor !!omap
21 |   - 1: a
22 |   - 2: b
23 |   - foo: bar
24 | 
25 | - !!pairs
26 |   - 0: {<<: *anchor, 2: c}
27 |   - 1: a2 [also part of the plain scalar]
28 |   - 2: :another scalar {}
29 |   - !e!float 3: !<tag:example.com,2000:app/int> 1 - 3
30 | 
31 | - {? !!int '12' : value,
32 |    ? !!str foo : :bar}
33 | 
34 | - - key: {more key: baz}
35 |     asdf: ~
36 | 
37 |     ? |-
38 |       block scalar as key
39 |     # comment here
40 |     : !!str >5
41 |       block scalar as value
42 | ...
43 | 


--------------------------------------------------------------------------------
/test/samples/yaml/sidekiq.standard.yml:
--------------------------------------------------------------------------------
 1 | ruby_version: 2.5.0
 2 | fix: false
 3 | parallel: true
 4 | ignore:
 5 |   - test/**/*
 6 |   - examples/**/*
 7 |   - myapp/**/*
 8 |   - 'lib/sidekiq.rb':
 9 |     - Lint/InheritException
10 |   - 'lib/sidekiq/extensions/**/*':
11 |     - Style/MethodMissingSuper
12 |     - Style/MissingRespondToMissing
13 |   - 'lib/**/*':
14 |     - Naming/AsciiIdentifiers
15 |     - Lint/RescueException
16 |     - Security/YAMLLoad
17 |     - Naming/AccessorMethodName
18 |     - Naming/MethodName
19 |     - Style/GlobalVars
20 |     - Style/Alias
21 | 


--------------------------------------------------------------------------------
/test/samples/yaml/types.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | numbers:
 3 |     foo: .inf
 4 |     bar: -.Inf
 5 |     plop: .NAN
 6 |     foo : 1230.15
 7 |     bar : 1230150.0
 8 |     foo: 1230.15
 9 |     bar:  12.3015e+05
10 |     foo: 12345
11 |     bar: 0x12d4
12 |     plop: 023332
13 | nulls:
14 |     foo: ~
15 |     bar: null
16 | booleans:
17 |     foo: True
18 |     bar: False
19 |     light: On
20 |     TV: Off
21 | 


--------------------------------------------------------------------------------
/test/tests/buildRules.test.ts:
--------------------------------------------------------------------------------
 1 | import { assert } from "chai"
 2 | 
 3 | import {
 4 |     SemanticColor,
 5 |     TextMateRule,
 6 |     TextMateRuleData,
 7 | } from "@types"
 8 | 
 9 | import {
10 |     buildRules,
11 |     DarkPlusPalette,
12 | } from "@src"
13 | 
14 | const viml: TextMateRuleData[] = [
15 |     {
16 |         scopes: [
17 |             "constant.character.map.viml",
18 |         ],
19 |         foreground: SemanticColor.Chars,
20 |         fontStyle:  "italic",
21 |     },
22 | ]
23 | 
24 | describe("buildRules", function() {
25 |     it("basic functionality", function() {
26 |         const have = buildRules(DarkPlusPalette, viml)
27 |         const want: TextMateRule[] = [
28 |             {
29 |                 "scope": [
30 |                     "constant.character.map.viml",
31 |                 ],
32 |                 "settings": {
33 |                     "foreground": "#d7ba7d",
34 |                     fontStyle:    "italic",
35 |                 },
36 |             },
37 |         ]
38 |         assert.deepEqual(have, want)
39 |     })
40 | })
41 | 


--------------------------------------------------------------------------------
/test/tests/example.test.ts:
--------------------------------------------------------------------------------
 1 | import { assert } from "chai"
 2 | // import { suite, test } from "@testdeck/mocha"
 3 | // import { expect } from 'chai'
 4 | 
 5 | // @suite
 6 | // class Hello {
 7 | 
 8 | //   @test
 9 | //   world() {
10 | //     // expect(false).to.be.true
11 | //   }
12 | // }
13 | 
14 | describe("Array", function() {
15 |     describe("#indexOf()", function() {
16 |         it("should return -1 when the value is not present", function() {
17 |             const have = [1, 2, 3].indexOf(4)
18 |             const want = -1
19 |             assert.equal(have, want)
20 |         })
21 |     })
22 | })
23 | 


--------------------------------------------------------------------------------
/test/tsconfig.test.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "extends": "../tsconfig.json",
 3 |     "compilerOptions": {
 4 |         "baseUrl": "./",
 5 |         "module": "CommonJS",
 6 |         "experimentalDecorators": true,
 7 |         "strictPropertyInitialization": false,
 8 |         "isolatedModules": false,
 9 |         "strict": false,
10 |         "noImplicitAny": false,
11 |         "typeRoots": [
12 |             "../node_modules/@types"
13 |         ],
14 |         "types": [
15 |             "node",
16 |             "mocha",
17 |             "chai"
18 |         ]
19 |     },
20 |     "exclude": [
21 |         "../node_modules",
22 |         "./samples"
23 |     ],
24 |     "include": [
25 |         "./tests/*.test.ts"
26 |     ],
27 | }
28 | 


--------------------------------------------------------------------------------
/todo.txt:
--------------------------------------------------------------------------------
 1 | x 2018-05-01 2018-03-21 Look into Ruby syntax.
 2 | x 2018-03-17 Language support for todo.txt. No wonder this editor still has problems.
 3 | 
 4 | 2018-03-17 Look into optional settings.
 5 | 2018-03-21 Poll for embedded template color.
 6 | 2018-03-20 Find better highlighting for embedded languages in HTML.
 7 | 2018-04-08 Italicize storage modifiers for js*. What does this mean?
 8 | 2018-05-02 Add +Go support for struct args in method calls.
 9 | 2018-05-02 Add +Go support for user-defined structs.
10 | 2018-05-02 Add +Python support for "(Any|Callable|Dict|Intersection|List|Optional|Sequence|Tuple|TypeVar|Union)"
11 | 2019-11-18 Add options. (highlight doc comments, italicize, etc.)
12 | 2022-02-07 Minify dist code.
13 | 2022-02-07 Add Feature Request / Enhancement issue template.
14 | 2022-02-07 Update .gitignore filetype associations. Add '.vscodeignore'.
15 | 2022-02-07 Find replacement for travis-ci (no free tier anymore)
16 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "ts-node": {
 3 |         "require": ["tsconfig-paths/register"],
 4 |         // "files": true,
 5 |     },
 6 |     "include": [
 7 |         "./src",
 8 |     ],
 9 |     // "files": [
10 |     //     "./src/@types/index.d.ts",
11 |     // ],
12 |     "exclude": [
13 |         "./ignore",
14 |         "./test/samples",
15 |     ],
16 |     "compilerOptions": {
17 |         "module": "CommonJS",
18 |         "target": "ES6",
19 |         "lib": [
20 |             "dom",
21 |             "esnext",
22 |         ],
23 |         "baseUrl": ".",
24 |         "paths": {
25 |             "@src/*": ["./src/*"],
26 |             "@lib": ["./src/lib/index.ts"],
27 |             "@types": ["./src/types/index.ts"],
28 |         },
29 |         "typeRoots": [
30 |             "./node_modules/@types"
31 |         ]
32 |     },
33 | }
34 | 


--------------------------------------------------------------------------------