turmali 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06bcafea0f78c8e5a95c998bae921490a31b233a
-  data.tar.gz: 8c0618191772b4335fe85a17a5a99bdcf72e46a2
+  metadata.gz: a69583d2a7925678fa9c48d77b797381222ddf1f
+  data.tar.gz: 5a45ddc15b1641e8310116b3efa33d64d39f0218
 SHA512:
-  metadata.gz: ca731d0ed9efb286a5ee7c602951878831af0db2d54887a451be0b97a5ce3781f2a616bbe7f6638ff129baf426ce511809caafc8a04d628f4e4c552ec1b9dbfb
-  data.tar.gz: 697603935ef127cfe705943b6e9c83f742a078212453ee132c3bb4e3d273d12a9767946748d85937ce4c6eb37d5ffd300d124c067951a075102f25091a51f3ee
+  metadata.gz: 20a56029b2eee2414ea964de2fd6e6fe4f9e9eee2a1af1356941998bc1fce4a73e6aad02a56f3cc373dbbe73988f80815632bb027dca05218db5902f40664972
+  data.tar.gz: 68d49e35f6fb59e1e856773b6b3f407a2d9e4c31ab05c27861b44e80f170d5f4db59491668fc98c8a2034e87b709e22c050cd41413baf88fd4c99d9a3d1cbc76

data/README.md

@@ -55,7 +55,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/eiffel
 ## 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/bin/tml

@@ -1,31 +1,21 @@
 #!/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"
+  puts "Turmali (#{Turmali::VERSION}) REPL, Type 'quit' or 'exit' to exit"
   loop do
-    line = Readline::readline(">> ")       # 1. Read
+    line = Readline::readline(">> ")       
+    exit if line == 'quit'
+    exit if line == 'exit'
     Readline::HISTORY.push(line)
-    value = interpreter.eval(line)         # 2. Eval
-    puts "=> #{value.ruby_value.inspect}"  # 3. Print
-  end                                      # 4. Loop
-  
+    value = interpreter.eval(line)         
+    puts "=> #{value.ruby_value.inspect}"  
+  end                                     
 end

data/lib/turmali/grammar.y

@@ -1,7 +1,5 @@
 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
@@ -13,9 +11,6 @@ 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 '!'
@@ -29,41 +24,13 @@ prechigh
   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] }
@@ -71,7 +38,6 @@ rule
   | Terminator                         { result = Nodes.new([]) }
   ;
 
-  # Every type of expression supported by our language is defined here.
   Expression:
     Literal
   | Call
@@ -86,20 +52,11 @@ rule
   | '(' 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]) }
@@ -107,15 +64,7 @@ rule
   | 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
@@ -133,13 +82,6 @@ rule
   | 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]]) }
@@ -155,7 +97,6 @@ rule
   | 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]) }
   ;
@@ -172,20 +113,10 @@ rule
     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
@@ -197,24 +128,19 @@ rule
   | 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"
+  require "turmali/lexer"
+  require "turmali/nodes"
 
 ---- inner
   def parse(code, show_tokens=false)

data/lib/turmali/interpreter.rb

@@ -5,8 +5,6 @@ require "turmali/runtime/context"
 require "turmali/runtime/class"
 require "turmali/runtime/bootstrap"
 
-# First, we create an simple wrapper class to encapsulate the interpretation process.
-# All this does is parse the code and call `eval` on the node at the top of the AST.
 class Interpreter
   def initialize
     @parser = Parser.new
@@ -17,28 +15,16 @@ class Interpreter
   end
 end
 
-# The `Nodes` class will always be at the top of the AST. Its only purpose it to
-# contain other nodes. It correspond to a block of code or a series of expressions.
-# 
-# The `eval` method of every node is the "interpreter" part of our language.
-# All nodes know how to evalualte themselves and return the result of their evaluation.
-# The `context` variable is the `Context` in which the node is evaluated (local
-# variables, current self and current class).
 class Nodes
   def eval(context)
     return_value = nil
     nodes.each do |node|
       return_value = node.eval(context)
     end
-    return_value || Constants["nil"] # Last result is return value (or nil if none).
+    return_value || Constants["nil"] 
   end
 end
 
-# We're using `Constants` that we created before when bootstrapping the runtime to access
-# the objects and classes from inside the runtime.
-#
-# Next, we implement `eval` on other node types. Think of that `eval` method as how the
-# node bring itself to life inside the runtime.
 class NumberNode
   def eval(context)
     Constants["Number"].new_with_value(value)
@@ -81,9 +67,6 @@ class GetLocalNode
   end
 end
 
-# When setting the value of a constant or a local variable, the `value` attribute
-# is a node, created by the parser. We need to evaluate the node first, to convert
-# it to an object, before storing it into a variable or constant.
 class SetConstantNode
   def eval(context)
     Constants[name] = value.eval(context)
@@ -96,14 +79,12 @@ class SetLocalNode
   end
 end
 
-# The `CallNode` for calling a method is a little more complex. It needs to set the receiver
-# first and then evaluate the arguments before calling the method.
 class CallNode
   def eval(context)
     if receiver
       value = receiver.eval(context)
     else
-      value = context.current_self # Default to `self` if no receiver.
+      value = context.current_self 
     end
     
     evaluated_arguments = arguments.map { |arg| arg.eval(context) }
@@ -111,7 +92,6 @@ class CallNode
   end
 end
 
-# Defining a method, using the `def` keyword, is done by adding a method to the current class.
 class DefNode
   def eval(context)
     method = TurmaliMethod.new(params, body)
@@ -119,21 +99,13 @@ class DefNode
   end
 end
 
-# Defining a class is done in three steps:
-#
-# 1. Reopen or define the class.
-# 2. Create a special context of evaluation (set `current_self` and `current_class` to the new class).
-# 3. Evaluate the body of the class inside that context.
-#
-# Check back how `DefNode` was implemented, adding methods to `context.current_class`. Here is
-# where we set the value of `current_class`.
 class ClassNode
   def eval(context)
-    turmali_class = Constants[name] # Check if class is already defined
+    turmali_class = Constants[name] 
     
-    unless turmali_class # Class doesn't exist yet
+    unless turmali_class 
       turmali_class = TurmaliClass.new
-      Constants[name] = turmali_class # Define the class in the runtime
+      Constants[name] = turmali_class 
     end
     
     class_context = Context.new(turmali_class, turmali_class)
@@ -143,14 +115,12 @@ class ClassNode
   end
 end
 
-# Finally, to implement `if` in our language,
-# we turn the condition node into a Ruby value to use Ruby's `if`.
 class IfNode
   def eval(context)
     if condition.eval(context).ruby_value
       body.eval(context)
-    else # If no body is evaluated, we return nil.
+    else 
       Constants["nil"]
     end
   end
-end
+end

data/lib/turmali/lexer.rb

@@ -1,72 +1,40 @@
-# Our lexer will be used like so: `Lexer.new.tokenize("code")`,
-# and will return an array of tokens (a token being a tuple of `[TOKEN_TYPE, TOKEN_VALUE]`).
 class Lexer
-  # First we define the special keywords of our language in a constant.
-  # It will be used later on in the tokenizing process to disambiguate
-  # an identifier (method name, local variable, etc.) from a keyword.
+
   KEYWORDS = ["def", "class", "if", "true", "false", "nil"]
   
   def tokenize(code)
-    code.chomp! # Remove extra line breaks
-    tokens = [] # This will hold the generated tokens
-    
-    # We need to know how deep we are in the indentation so
-    # we keep track of the current indentation level we are in, and previous ones in the stack
-    # so that when we dedent, we can check if we're on the correct level.
-    current_indent = 0 # number of spaces in the last indent
+    code.chomp! 
+    tokens = [] 
+
+    current_indent = 0 
     indent_stack = []
-    
-    # Here is how to implement a very simple scanner.
-    # Advance one character at the time until you find something to parse.
-    # We'll use regular expressions to scan from the current position (`i`)
-    # up to the end of the code.
-    i = 0 # Current character position
+
+    i = 0 
     while i < code.size
       chunk = code[i..-1]
       
-      # Each of the following `if/elsif`s will test the current code chunk with
-      # a regular expression. The order is important as we want to match `if`
-      # as a keyword, and not a method name, we'll need to apply it first.
-      #
-      # First, we'll scan for names: method names and variable names, which we'll call identifiers.
-      # Also scanning for special reserved keywords such as `if`, `def`
-      # and `true`.
       if identifier = chunk[/\A([a-z]\w*)/, 1]
-        if KEYWORDS.include?(identifier) # keywords will generate [:IF, "if"]
+        if KEYWORDS.include?(identifier) 
           tokens << [identifier.upcase.to_sym, identifier]
         else
           tokens << [:IDENTIFIER, identifier]
         end
-        i += identifier.size # skip what we just parsed
+        i += identifier.size 
       
-      # Now scanning for constants, names starting with a capital letter.
-      # Which means, class names are constants in our language.
       elsif constant = chunk[/\A([A-Z]\w*)/, 1]
         tokens << [:CONSTANT, constant]
         i += constant.size
-        
-      # Next, matching numbers. Our language will only support integers. But to add support for floats,
-      # you'd simply need to add a similar rule and adapt the regular expression accordingly.
+
       elsif number = chunk[/\A([0-9]+)/, 1]
         tokens << [:NUMBER, number.to_i]
         i += number.size
-        
-      # Of course, matching strings too. Anything between `"..."`.
+
       elsif string = chunk[/\A"([^"]*)"/, 1]
         tokens << [:STRING, string]
-        i += string.size + 2 # skip two more to exclude the `"`.
-      
-      # And here's the indentation magic! We have to take care of 3 cases:
-      # 
-      #     if true:  # 1) The block is created.
-      #       line 1
-      #       line 2  # 2) New line inside a block, at the same level.
-      #     continue  # 3) Dedent.
-      #
-      # This `elsif` takes care of the first case. The number of spaces will determine 
-      # the indent level.
-      elsif indent = chunk[/\A\:\n( +)/m, 1] # Matches ": <newline> <spaces>"
-        if indent.size <= current_indent # indent should go up when creating a block
+        i += string.size + 2 
+
+      elsif indent = chunk[/\A\:\n( +)/m, 1] 
+        if indent.size <= current_indent 
           raise "Bad indent level, got #{indent.size} indents, " +
                 "expected > #{current_indent}"
         end
@@ -74,41 +42,29 @@ class Lexer
         indent_stack.push(current_indent)
         tokens << [:INDENT, indent.size]
         i += indent.size + 2
-  
-      # The next `elsif` takes care of the two last cases:
-      #
-      # * Case 2: We stay in the same block if the indent level (number of spaces) is the
-      #   same as `current_indent`.
-      # * Case 3: Close the current block, if indent level is lower than `current_indent`.
-      elsif indent = chunk[/\A\n( *)/m, 1] # Matches "<newline> <spaces>"
-        if indent.size == current_indent # Case 2
-          tokens << [:NEWLINE, "\n"] # Nothing to do, we're still in the same block
-        elsif indent.size < current_indent # Case 3
+
+      elsif indent = chunk[/\A\n( *)/m, 1] 
+        if indent.size == current_indent 
+          tokens << [:NEWLINE, "\n"] 
+        elsif indent.size < current_indent 
           while indent.size < current_indent
             indent_stack.pop
             current_indent = indent_stack.last || 0
             tokens << [:DEDENT, indent.size]
           end
           tokens << [:NEWLINE, "\n"]
-        else # indent.size > current_indent, error!
-          raise "Missing ':'" # Cannot increase indent level without using ":"
+        else 
+          raise "Missing ':'" 
         end
         i += indent.size + 1
       
-      # Long operators such as `||`, `&&`, `==`, etc.
-      # will be matched by the following block.
-      # One character long operators are matched by the catch all `else` at the bottom.
       elsif operator = chunk[/\A(\|\||&&|==|!=|<=|>=)/, 1]
         tokens << [operator, operator]
         i += operator.size
-      
-      # We're ignoring spaces. Contrary to line breaks, spaces are meaningless in our language.
-      # That's why we don't create tokens for them. They are only used to separate other tokens.
+
       elsif chunk.match(/\A /)
         i += 1
-      
-      # Finally, catch all single characters, mainly operators.
-      # We treat all other single characters as a token. Eg.: `( ) , . ! + - <`.
+
       else
         value = chunk[0,1]
         tokens << [value, value]
@@ -117,13 +73,11 @@ class Lexer
       end
       
     end
-    
-    # Close all open blocks. If the code ends without dedenting, this will take care of
-    # balancing the `INDENT`...`DEDENT`s.
+
     while indent = indent_stack.pop
       tokens << [:DEDENT, indent_stack.first || 0]
     end
     
     tokens
   end
-end
+end

data/lib/turmali/nodes.rb

@@ -1,26 +1,3 @@
-# The first type is responsible for holding a collection of nodes,
-# each one representing an expression. You can think of it as the internal
-# representation of a block of code.
-#
-# Here we define nodes as Ruby classes that inherit from a `Struct`. This is a
-# simple way, in Ruby, to create a class that holds some attributes (values).
-# It is almost equivalent to:
-# 
-#     class Nodes
-#       def initialize(nodes)
-#         @nodes = nodes
-#       end
-#
-#       def nodes
-#         @nodes
-#       end
-#     end
-#
-#     n = Nodes.new("this is stored @nodes")
-#     n.nodes # => "this is stored @nodes"
-#
-# But Ruby's `Struct` takes care of overriding the `==` operator for us and a bunch of
-# other things that will make testing easier.
 class Nodes < Struct.new(:nodes)
   def <<(node) # Useful method for adding a node on the fly.
     nodes << node
@@ -28,9 +5,6 @@ class Nodes < Struct.new(:nodes)
   end
 end
 
-# Literals are static values that have a Ruby representation. For example, a string, a number, 
-# `true`, `false`, `nil`, etc. We define a node for each one of those and store their Ruby
-# representation inside their `value` attribute.
 class LiteralNode < Struct.new(:value); end
 
 class NumberNode < LiteralNode; end
@@ -55,34 +29,18 @@ class NilNode < LiteralNode
   end
 end
 
-# The node for a method call holds the `receiver`,
-# the object on which the method is called, the `method` name and its
-# arguments, which are other nodes.
 class CallNode < Struct.new(:receiver, :method, :arguments); end
 
-# Retrieving the value of a constant by its `name` is done by the following node.
 class GetConstantNode < Struct.new(:name); end
 
-# And setting its value is done by this one. The `value` will be a node. If we're
-# storing a number inside a constant, for example, `value` would contain an instance
-# of `NumberNode`.
 class SetConstantNode < Struct.new(:name, :value); end
 
-# Similar to the previous nodes, the next ones are for dealing with local variables.
 class GetLocalNode < Struct.new(:name); end
 
 class SetLocalNode < Struct.new(:name, :value); end
 
-# Each method definition will be stored into the following node. It holds the `name` of the method,
-# the name of its parameters (`params`) and the `body` to evaluate when the method is called, which
-# is a tree of node, the root one being a `Nodes` instance.
 class DefNode < Struct.new(:name, :params, :body); end
 
-# Class definitions are stored into the following node. Once again, the `name` of the class and
-# its `body`, a tree of nodes.
 class ClassNode < Struct.new(:name, :body); end
 
-# `if` control structures are stored in a node of their own. The `condition` and `body` will also
-# be nodes that need to be evaluated at some point.
-# Look at this node if you want to implement other control structures like `while`, `for`, `loop`, etc.
 class IfNode  < Struct.new(:condition, :body); end

data/lib/turmali/runtime/bootstrap.rb

@@ -1,23 +1,16 @@
 require "turmali/runtime/class"
-# First, we create a Ruby Hash in which we'll store all constants accessible from inside
-# our runtime.
-# Then, we populate this Hash with the core classes of our language.
+
 Constants = {}
 
-Constants["Class"] = TurmaliClass.new                 # Defining the `Class` class.
-Constants["Class"].runtime_class = Constants["Class"] # Setting `Class.class = Class`.
-Constants["Object"] = TurmaliClass.new                # Defining the `Object` class
-Constants["Number"] = TurmaliClass.new                # Defining the `Number` class
+Constants["Class"] = TurmaliClass.new                 
+Constants["Class"].runtime_class = Constants["Class"] 
+Constants["Object"] = TurmaliClass.new                
+Constants["Number"] = TurmaliClass.new                
 Constants["String"] = TurmaliClass.new
 
-# The root context will be the starting point where all our programs will
-# start their evaluation. This will also set the value of `self` at the root
-# of our programs.
 root_self = Constants["Object"].new
 RootContext = Context.new(root_self)
 
-# Everything is an object in our language, even `true`, `false` and `nil`. So they need
-# to have a class too.
 Constants["TrueClass"] = TurmaliClass.new
 Constants["FalseClass"] = TurmaliClass.new
 Constants["NilClass"] = TurmaliClass.new
@@ -26,23 +19,11 @@ Constants["true"] = Constants["TrueClass"].new_with_value(true)
 Constants["false"] = Constants["FalseClass"].new_with_value(false)
 Constants["nil"] = Constants["NilClass"].new_with_value(nil)
 
-# Now that we have injected all the core classes into the runtime, we can define
-# methods on those classes.
-#
-# The first method we'll define will allow us to do `Object.new` or
-# `Number.new`. Keep in mind, `Object` or `Number`
-# are instances of the `Class` class. By defining the `new` method
-# on `Class`, it will be accessible on all its instances.
 Constants["Class"].def :new do |receiver, arguments|
   receiver.new
 end
 
-# Next, we'll define the `print` method. Since we want to be able to call it
-# from everywhere, we'll define it on `Object`.
-# Remember from the parser's `Call` rule, methods without any receiver will be
-# sent to `self`. So `print()` is the same as `self.print()`, and
-# `self` will always be an instance of `Object`.
 Constants["Object"].def :print do |receiver, arguments|
   puts arguments.first.ruby_value
-  Constants["nil"] # We always want to return objects from our runtime
+  Constants["nil"] 
 end

data/lib/turmali/runtime/class.rb

@@ -2,8 +2,7 @@ require "turmali/runtime/object"
 require "turmali/runtime/context"
 
 class TurmaliClass < TurmaliObject
-  # Classes are objects in Turmali so they inherit from TurmaliObject.
-  
+
   attr_reader :runtime_methods
 
   def initialize
@@ -11,25 +10,20 @@ class TurmaliClass < TurmaliObject
     @runtime_class = Constants["Class"]
   end
 
-  # Lookup a method
   def lookup(method_name)
     method = @runtime_methods[method_name]
     raise "Method not found: #{method_name}" if method.nil?
     method
   end
 
-  # Helper method to define a method on this class from Ruby.
   def def(name, &block)
     @runtime_methods[name.to_s] = block
   end
 
-  # Create a new instance of this class
   def new
     TurmaliObject.new(self)
   end
-  
-  # Create an instance of this Turmali class that holds a Ruby value. Like a String, 
-  # Number or true.
+
   def new_with_value(value)
     TurmaliObject.new(self, value)
   end

data/lib/turmali/runtime/method.rb

@@ -5,16 +5,12 @@ class TurmaliMethod
   end
   
   def call(receiver, arguments)
-    # Create a context of evaluation in which the method will execute.
     context = Context.new(receiver)
-    
-    # Assign passed arguments to local variables.
+
     @params.each_with_index do |param, index|
       context.locals[param] = arguments[index]
     end
-    
-    # The body is a node (created in the parser).
-    # We'll talk in details about the `eval` method in the interpreter chapter.
+
     @body.eval(context)
   end
 end

data/lib/turmali/runtime/object.rb

@@ -1,8 +1,4 @@
 class TurmaliObject  
-  # Each object has a class (named <code>runtime_class</code> to prevent conflicts
-  # with Ruby's <code>class</code> keyword).
-  # Optionally an object can hold a Ruby value. Eg.: numbers and strings will store their
-  # number or string Ruby equivalent in that variable.
   attr_accessor :runtime_class, :ruby_value
 
   def initialize(runtime_class, ruby_value=self)
@@ -10,9 +6,6 @@ class TurmaliObject
     @ruby_value = ruby_value
   end
 
-  # Like a typical Class-based runtime model, we store methods in the class of the
-  # object. When calling a method on an object, we need to first lookup that
-  # method in the class, and then call it.
   def call(method, arguments=[])
     @runtime_class.lookup(method).call(self, arguments)
   end

data/lib/turmali/version.rb

@@ -1,3 +1,3 @@
 module Turmali
-  VERSION = "0.0.1"
-end
+  VERSION = "0.0.2"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turmali
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Eiffel Qiu
@@ -64,7 +64,6 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# 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/