turmali 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06bcafea0f78c8e5a95c998bae921490a31b233a
+  data.tar.gz: 8c0618191772b4335fe85a17a5a99bdcf72e46a2
+SHA512:
+  metadata.gz: ca731d0ed9efb286a5ee7c602951878831af0db2d54887a451be0b97a5ce3781f2a616bbe7f6638ff129baf426ce511809caafc8a04d628f4e4c552ec1b9dbfb
+  data.tar.gz: 697603935ef127cfe705943b6e9c83f742a078212453ee132c3bb4e3d273d12a9767946748d85937ce4c6eb37d5ffd300d124c067951a075102f25091a51f3ee

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at eiffelqiu@qq.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in turmali.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Eiffel Qiu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Turmali
+
+Turmali is a website building language.
+
+```
+class Turmali:
+  def name:
+    "I'm Turmali"
+  def turmali:
+    100
+
+
+tml = Turmali.new
+print(tml.name)
+print(tml.turmali)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'turmali'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install turmali
+
+## Usage
+
+```The Turmali language!
+
+ usage:
+   ./tml example.tml # to eval a file
+   ./tml             # to start the REPL
+
+ on Windows run with: ruby -I. tml [options]
+```
+
+## Development
+
+After checking out the repo,  run `rake spec` to run the tests. You can also run `bin/tml` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eiffelqiu/turmali. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Turmali project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/eiffelqiu/turmali/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/tml

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# The Turmali language!
+# 
+# usage:
+#   ./tml example.tml # to eval a file
+#   ./tml             # to start the REPL
+#
+# on Windows run with: ruby -I. tml [options]
+
+require "bundler/setup"
+require "turmali"
+
+require "readline"
+
+interpreter = Interpreter.new
+
+# If a file is given we eval it.
+if file = ARGV.first
+  interpreter.eval File.read(file)
+
+# Start the REPL, read-eval-print-loop, or interactive interpreter
+else
+  puts "Turmali REPL, CTRL+C to quit"
+  loop do
+    line = Readline::readline(">> ")       # 1. Read
+    Readline::HISTORY.push(line)
+    value = interpreter.eval(line)         # 2. Eval
+    puts "=> #{value.ruby_value.inspect}"  # 3. Print
+  end                                      # 4. Loop
+  
+end

data/lib/turmali.rb

@@ -0,0 +1,2 @@
+require "turmali/version"
+require "turmali/interpreter"

data/lib/turmali/grammar.y

@@ -0,0 +1,228 @@
+class Parser
+
+# We need to tell the parser what tokens to expect. So each type of token produced
+# by our lexer needs to be declared here.
+token IF
+token DEF
+token CLASS
+token NEWLINE
+token NUMBER
+token STRING
+token TRUE FALSE NIL
+token IDENTIFIER
+token CONSTANT
+token INDENT DEDENT
+
+# Here is the Operator Precedence Table. As presented before, it tells the parser in
+# which order to parse expressions containing operators.
+# This table is based on the [C and C++ Operator Precedence Table](http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence).
+prechigh
+  left  '.'
+  right '!'
+  left  '*' '/'
+  left  '+' '-'
+  left  '>' '>=' '<' '<='
+  left  '==' '!='
+  left  '&&'
+  left  '||'
+  right '='
+  left  ','
+preclow
+
+# In the following `rule` section, we define the parsing rules.
+# All rules are declared using the following format:
+#
+#     RuleName:
+#       OtherRule TOKEN AnotherRule    { result = Node.new }
+#     | OtherRule                      { ... }
+#     ;
+#
+# In the action section (inside the `{...}` on the right), you can do the following:
+#
+# * Assign to `result` the value returned by the rule, usually a node for the AST.
+# * Use `val[index of expression]` to get the `result` of a matched
+#   expressions on the left.
+rule
+  # First, parsers are dumb, we need to explicitly tell it how to handle empty
+  # programs. This is what the first rule does. Note that everything between `/* ... */` is
+  # a comment.
+  Program:
+    /* nothing */                      { result = Nodes.new([]) }
+  | Expressions                        { result = val[0] }
+  ;
+  
+  # Next, we define what a list of expressions is. Simply put, it's series of expressions separated by a
+  # terminator (a new line or `;` as defined later). But once again, we need to explicitly
+  # define how to handle trailing and orphans line breaks (the last two lines).
+  #
+  # One very powerful trick we'll use to define variable rules like this one
+  # (rules which can match any number of tokens) is *left-recursion*. Which means we reference
+  # the rule itself, directly or indirectly, on the left side **only**. This is true for the current
+  # type of parser we're using (LR). For other types of parsers like ANTLR (LL), it's the opposite,
+  # you can only use right-recursion.
+  #
+  # As you'll see bellow, the `Expressions` rule references `Expressions` itself.
+  # In other words, a list of expressions can be another list of expressions followed by
+  # another expression.
+  Expressions:
+    Expression                         { result = Nodes.new(val) }
+  | Expressions Terminator Expression  { result = val[0] << val[2] }
+  | Expressions Terminator             { result = val[0] }
+  | Terminator                         { result = Nodes.new([]) }
+  ;
+
+  # Every type of expression supported by our language is defined here.
+  Expression:
+    Literal
+  | Call
+  | Operator
+  | GetConstant
+  | SetConstant
+  | GetLocal
+  | SetLocal
+  | Def
+  | Class
+  | If
+  | '(' Expression ')'    { result = val[1] }
+  ;
+
+  # Notice how we implement support for parentheses using the previous rule. 
+  # `'(' Expression ')'` will force the parsing of `Expression` in its
+  # entirety first. Parentheses will then be discarded leaving only the fully parsed expression.
+  #
+  # Terminators are tokens that can terminate an expression.
+  # When using tokens to define rules, we simply reference them by their type which we defined in
+  # the lexer.
+  Terminator:
+    NEWLINE
+  | ";"
+  ;
+  
+  # Literals are the hard-coded values inside the program. If you want to add support
+  # for other literal types, such as arrays or hashes, this it where you'd do it.
+  Literal:
+    NUMBER                        { result = NumberNode.new(val[0]) }
+  | STRING                        { result = StringNode.new(val[0]) }
+  | TRUE                          { result = TrueNode.new }
+  | FALSE                         { result = FalseNode.new }
+  | NIL                           { result = NilNode.new }
+  ;
+  
+  # Method calls can take three forms:
+  #
+  # * Without a receiver (`self` is assumed): `method(arguments)`.
+  # * With a receiver: `receiver.method(arguments)`.
+  # * And a hint of syntactic sugar so that we can drop
+  #   the `()` if no arguments are given: `receiver.method`.
+  #
+  # Each one of those is handled by the following rule.
+  Call:
+    IDENTIFIER Arguments          { result = CallNode.new(nil, val[0], val[1]) }
+  | Expression "." IDENTIFIER
+      Arguments                   { result = CallNode.new(val[0], val[2], val[3]) }
+  | Expression "." IDENTIFIER     { result = CallNode.new(val[0], val[2], []) }
+  ;
+
+  Arguments:
+    "(" ")"                       { result = [] }
+  | "(" ArgList ")"               { result = val[1] }
+  ;
+
+  ArgList:
+    Expression                    { result = val }
+  | ArgList "," Expression        { result = val[0] << val[2] }
+  ;
+  
+
+  # In our language, like in Ruby, operators are converted to method calls.
+  # So `1 + 2` will be converted to `1.+(2)`.
+  # `1` is the receiver of the `+` method call, passing `2`
+  # as an argument.
+  # Operators need to be defined individually for the Operator Precedence Table to take
+  # action.
+  Operator:
+    Expression '||' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '&&' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '==' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '!=' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '>'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '>=' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '<'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '<=' Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '+'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '-'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '*'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  | Expression '/'  Expression  { result = CallNode.new(val[0], val[1], [val[2]]) }
+  ;
+  
+  # Then we have rules for getting and setting values of constants and local variables.
+  GetConstant:
+    CONSTANT                      { result = GetConstantNode.new(val[0]) }
+  ;
+  
+  SetConstant:
+    CONSTANT "=" Expression       { result = SetConstantNode.new(val[0], val[2]) }
+  ;
+
+  GetLocal:
+    IDENTIFIER                    { result = GetLocalNode.new(val[0]) }
+  ;
+  
+  SetLocal:
+    IDENTIFIER "=" Expression     { result = SetLocalNode.new(val[0], val[2]) }
+  ;
+
+  # Our language uses indentation to separate blocks of code. But the lexer took care of all
+  # that complexity for us and wrapped all blocks in `INDENT ... DEDENT`. A block
+  # is simply an increment in indentation followed by some code and closing with an equivalent
+  # decrement in indentation.
+  # 
+  # If you'd like to use curly brackets or `end` to delimit blocks instead, you'd
+  # simply need to modify this one rule.
+  # You'll also need to remove the indentation logic from the lexer.
+  Block:
+    INDENT Expressions DEDENT     { result = val[1] }
+  ;
+  
+  # The `def` keyword is used for defining methods. Once again, we're introducing
+  # a bit of syntactic sugar here to allow skipping the parentheses when there are no parameters.
+  Def:
+    DEF IDENTIFIER Block          { result = DefNode.new(val[1], [], val[2]) }
+  | DEF IDENTIFIER
+      "(" ParamList ")" Block     { result = DefNode.new(val[1], val[3], val[5]) }
+  ;
+
+  ParamList:
+    /* nothing */                 { result = [] }
+  | IDENTIFIER                    { result = val }
+  | ParamList "," IDENTIFIER      { result = val[0] << val[2] }
+  ;
+  
+  # Class definition is similar to method definition.
+  # Class names are also constants because they start with a capital letter.
+  Class:
+    CLASS CONSTANT Block          { result = ClassNode.new(val[1], val[2]) }
+  ;
+  
+  # Finally, `if` is similar to `class` but receives a *condition*.
+  If:
+    IF Expression Block           { result = IfNode.new(val[1], val[2]) }
+  ;
+end
+
+# The final code at the bottom of this Racc file will be put as-is in the generated `Parser` class.
+# You can put some code at the top (`header`) and some inside the class (`inner`).
+---- header
+  require "lexer"
+  require "nodes"
+
+---- inner
+  def parse(code, show_tokens=false)
+    @tokens = Lexer.new.tokenize(code) # Tokenize the code using our lexer
+    puts @tokens.inspect if show_tokens
+    do_parse # Kickoff the parsing process
+  end
+  
+  def next_token
+    @tokens.shift
+  end