Initial commit

.gitignore

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

.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

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 ahem.gemspec
+gemspec

Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    ahem (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ahem!
+  bundler (~> 1.17)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.3

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Dylan Baker
+
+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.

README.md

@@ -0,0 +1,39 @@
+# Ahem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ahem`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ahem'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ahem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` 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/[USERNAME]/ahem.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

Rakefile

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

ahem.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ahem/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ahem"
+  spec.version       = Ahem::VERSION
+  spec.authors       = ["Dylan Baker"]
+  spec.email         = ["dylan@simulacrum.party"]
+
+  spec.summary       = %q{A little language}
+  spec.homepage      = "https://git.sr.ht/~simulacrumparty/ahem"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

bin/ahem

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'ahem'
+
+CLI::run

bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ahem"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

lib/ahem.rb

@@ -0,0 +1,9 @@
+require 'ahem/ast'
+require 'ahem/cli'
+require 'ahem/lexer'
+require 'ahem/parser'
+require 'ahem/token'
+require 'ahem/token_kinds'
+require 'ahem/version'
+
+module Ahem; end

lib/ahem/ast.rb

@@ -0,0 +1,18 @@
+module AST
+  require 'ahem/ast/array'
+  require 'ahem/ast/binary'
+  require 'ahem/ast/block'
+  require 'ahem/ast/boolean'
+  require 'ahem/ast/branch'
+  require 'ahem/ast/class_definition'
+  require 'ahem/ast/conditional'
+  require 'ahem/ast/function_call'
+  require 'ahem/ast/function_definition'
+  require 'ahem/ast/identifier'
+  require 'ahem/ast/member'
+  require 'ahem/ast/null'
+  require 'ahem/ast/number'
+  require 'ahem/ast/operators'
+  require 'ahem/ast/string'
+  require 'ahem/ast/variable_declaration'
+end

lib/ahem/ast/array.rb

@@ -0,0 +1,11 @@
+class AST::Array
+  attr_reader :elements
+
+  def initialize(elements)
+    @elements = elements
+  end
+
+  def ==(other)
+    other.is_a?(AST::Array) && other.elements == @elements
+  end
+end

lib/ahem/ast/binary.rb

@@ -0,0 +1,14 @@
+class AST::Binary
+  attr_reader :operation, :left, :right
+
+  def initialize(operation, left, right)
+    @operation = operation
+    @left = left
+    @right = right
+  end
+
+  def ==(other)
+    other.operation == @operation && other.left == @left &&
+      other.right == @right
+  end
+end

lib/ahem/ast/block.rb

@@ -0,0 +1,11 @@
+class AST::Block
+  attr_reader :statements
+
+  def initialize(statements)
+    @statements = statements
+  end
+
+  def ==(other)
+    other.is_a?(AST::Block) && other.statements == @statements
+  end
+end

lib/ahem/ast/boolean.rb

@@ -0,0 +1,11 @@
+class AST::Boolean
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def ==(other)
+    other.is_a?(AST::Boolean) && other.value == @value
+  end
+end

lib/ahem/ast/branch.rb

@@ -0,0 +1,13 @@
+class AST::Branch
+  attr_reader :condition, :block
+
+  def initialize(condition, block)
+    @condition = condition
+    @block = block
+  end
+
+  def ==(other)
+    other.is_a?(AST::Branch) && other.condition == @condition &&
+      other.block == @block
+  end
+end

lib/ahem/ast/class_definition.rb

@@ -0,0 +1,15 @@
+class AST::ClassDefinition
+  attr_reader :name, :members, :methods
+
+  def initialize(name, members, methods)
+    @name = name
+    @members = members
+    @methods = methods
+  end
+
+  def ==(other)
+    other.is_a?(AST::ClassDefinition) && other.name == @name &&
+      other.members == @members &&
+      other.methods == @methods
+  end
+end

lib/ahem/ast/conditional.rb

@@ -0,0 +1,11 @@
+class AST::Conditional
+  attr_reader :branches
+
+  def initialize(branches)
+    @branches = branches
+  end
+
+  def ==(other)
+    other.is_a?(AST::Conditional) && other.branches == @branches
+  end
+end

lib/ahem/ast/function_call.rb

@@ -0,0 +1,13 @@
+class AST::FunctionCall
+  attr_reader :function, :arguments
+
+  def initialize(function, arguments)
+    @function = function
+    @arguments = arguments
+  end
+
+  def ==(other)
+    other.is_a?(AST::FunctionCall) && other.function == @function &&
+      other.arguments == @arguments
+  end
+end

lib/ahem/ast/function_definition.rb

@@ -0,0 +1,15 @@
+class AST::FunctionDefinition
+  attr_reader :name, :parameters, :body
+
+  def initialize(name, parameters, body)
+    @name = name
+    @parameters = parameters
+    @body = body
+  end
+
+  def ==(other)
+    other.is_a?(AST::FunctionDefinition) && other.name == @name &&
+      other.parameters == @parameters &&
+      other.body == @body
+  end
+end

lib/ahem/ast/identifier.rb

@@ -0,0 +1,11 @@
+class AST::Identifier
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    other.is_a?(AST::Identifier) && other.name == @name
+  end
+end

lib/ahem/ast/member.rb

@@ -0,0 +1,13 @@
+class AST::Member
+  attr_reader :name, :is_public
+
+  def initialize(name, is_public)
+    @name = name
+    @is_public = is_public
+  end
+
+  def ==(other)
+    other.is_a?(AST::Member) && other.name == @name &&
+      other.is_public == @is_public
+  end
+end

lib/ahem/ast/null.rb

@@ -0,0 +1,5 @@
+class AST::Null
+  def ==(other)
+    other.is_a?(AST::Null)
+  end
+end

lib/ahem/ast/number.rb

@@ -0,0 +1,11 @@
+class AST::Number
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def ==(other)
+    other.is_a?(AST::Number) && other.value == @value
+  end
+end

lib/ahem/ast/operators.rb

@@ -0,0 +1,12 @@
+module AST::Operators
+  ADD = :+
+  SUBTRACT = :-
+  MULTIPLY = :*
+  DIVIDE = :/
+  LESS_THAN = :<
+  GREATER_THAN = :>
+  LESS_THAN_OR_EQUAL = :<=
+  GREATER_THAN_OR_EQUAL = :>=
+  OR = :or
+  AND = :and
+end

lib/ahem/ast/string.rb

@@ -0,0 +1,11 @@
+class AST::String
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def ==(other)
+    other.is_a?(AST::String) && other.value == @value
+  end
+end

lib/ahem/ast/variable_declaration.rb

@@ -0,0 +1,13 @@
+class AST::VariableDeclaration
+  attr_reader :name, :value
+
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
+
+  def ==(other)
+    other.is_a?(AST::VariableDeclaration) && other.name == @name &&
+      other.value == @value
+  end
+end

lib/ahem/cli.rb

@@ -0,0 +1,9 @@
+require 'pp'
+
+class CLI
+  def self.run
+    file = ARGV.first
+    source = File.read(file).strip
+    Parser.new(Lexer.new(source)).parse.each { |node| pp node }
+  end
+end

lib/ahem/lexer.rb

@@ -0,0 +1,145 @@
+class Lexer
+  def initialize(source)
+    @source = source.split("\n").join(' ')
+    @position = 0
+  end
+
+  def get_token
+    return Token.new(TokenKinds::EOF) if at_end
+
+    @position += 1 while !at_end && @source.slice(@position).match(/\s/)
+
+    source = @source.slice(@position..-1)
+    if source.match(/^null/)
+      @position += 4
+      Token.new(TokenKinds::NULL)
+    elsif source.match(/^true/)
+      @position += 4
+      Token.new(TokenKinds::BOOLEAN, true)
+    elsif source.match(/^false/)
+      @position += 5
+      Token.new(TokenKinds::BOOLEAN, false)
+    elsif source.match(/^if/)
+      @position += 2
+      Token.new(TokenKinds::IF)
+    elsif source.match(/^elseif/)
+      @position += 6
+      Token.new(TokenKinds::ELSEIF)
+    elsif source.match(/^else/)
+      @position += 4
+      Token.new(TokenKinds::ELSE)
+    elsif source.match(/^\d+(\.\d+)?/)
+      number = source.match(/^\d+(\.\d+)?/)[0]
+      @position += number.size
+      Token.new(TokenKinds::NUMBER, number.to_f)
+    elsif source.match(/^"(.*)"/)
+      string = source.match(/^"([^"]*)"/)[1]
+      @position += (string.size + 2)
+      Token.new(TokenKinds::STRING, string)
+    elsif source.match(/^\+/)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :+)
+    elsif source.match(/^\-/)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :-)
+    elsif source.match(/^\*/)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :*)
+    elsif source.match(%r{^\/})
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :/)
+    elsif source.match(/^\{/)
+      @position += 1
+      Token.new(TokenKinds::LBRACE)
+    elsif source.match(/^\}/)
+      @position += 1
+      Token.new(TokenKinds::RBRACE)
+    elsif source.match(/^\(/)
+      @position += 1
+      Token.new(TokenKinds::LPAREN)
+    elsif source.match(/^\)/)
+      @position += 1
+      Token.new(TokenKinds::RPAREN)
+    elsif source.match(/^\[/)
+      @position += 1
+      Token.new(TokenKinds::LBRACKET)
+    elsif source.match(/^\]/)
+      @position += 1
+      Token.new(TokenKinds::RBRACKET)
+    elsif source.match(/^\;/)
+      @position += 1
+      Token.new(TokenKinds::SEMICOLON)
+    elsif source.match(/^,/)
+      @position += 1
+      Token.new(TokenKinds::COMMA)
+    elsif source.match(/^\./)
+      @position += 1
+      Token.new(TokenKinds::DOT)
+    elsif source.match(/^\<=/)
+      @position += 2
+      Token.new(TokenKinds::OPERATOR, :<=)
+    elsif source.match(/^\>\=/)
+      @position += 2
+      Token.new(TokenKinds::OPERATOR, :>=)
+    elsif source.match(/^\</)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :<)
+    elsif source.match(/^\>/)
+      @position += 1
+      Token.new(TokenKinds::OPERATOR, :>)
+    elsif source.match(/^and/)
+      @position += 3
+      Token.new(TokenKinds::OPERATOR, :and)
+    elsif source.match(/^or/)
+      @position += 2
+      Token.new(TokenKinds::OPERATOR, :or)
+    elsif source.match(/^\=/)
+      @position += 1
+      Token.new(TokenKinds::EQUALS)
+    elsif source.match(/^let/)
+      @position += 3
+      Token.new(TokenKinds::LET)
+    elsif source.match(/^function/)
+      @position += 8
+      Token.new(TokenKinds::FUNCTION)
+    elsif source.match(/^class/)
+      @position += 5
+      Token.new(TokenKinds::CLASS)
+    elsif source.match(/^public/)
+      @position += 6
+      Token.new(TokenKinds::PUBLIC)
+    elsif source.match(/^private/)
+      @position += 7
+      Token.new(TokenKinds::PRIVATE)
+    elsif source.match(/^[a-z][a-zA-Z0-9_]*/)
+      identifier = source.match(/^[a-z][a-zA-Z0-9_]*/)[0]
+      @position += identifier.size
+      Token.new(TokenKinds::IDENTIFIER, identifier)
+    elsif source.match(/^[A-Z][a-zA-Z0-9_]*/)
+      class_name = source.match(/^[A-Z][a-zA-Z0-9_]*/)[0]
+      @position += class_name.size
+      Token.new(TokenKinds::CLASS_NAME, class_name)
+    else
+      throw "Unrecognized character #{source[0]}"
+    end
+  end
+
+  def scan_all
+    tokens = Array.new
+    until at_end
+      if @source.slice(@position).match(/\s/)
+        @position += 1
+      else
+        tokens << get_token
+      end
+    end
+    tokens << Token.new(TokenKinds::EOF)
+    tokens
+  end
+
+  private
+
+  def at_end
+    @position == @source.size
+  end
+end

lib/ahem/parser.rb

@@ -0,0 +1,299 @@
+class Parser
+  def initialize(lexer)
+    @lexer = lexer
+    @current_token = @lexer.get_token
+  end
+
+  def parse
+    tree = Array.new
+
+    tree << statement until at_end
+
+    tree
+  end
+
+  def statement
+    if @current_token.type == TokenKinds::IF
+      conditional
+    elsif @current_token.type == TokenKinds::LET
+      variable_declaration
+    elsif @current_token.type == TokenKinds::FUNCTION
+      function_definition
+    elsif @current_token.type == TokenKinds::CLASS
+      class_definition
+    else
+      expr = expression
+      eat(TokenKinds::SEMICOLON)
+      expr
+    end
+  end
+
+  def variable_declaration
+    eat(TokenKinds::LET)
+    name = identifier
+    eat(TokenKinds::EQUALS)
+    value = expression
+    eat(TokenKinds::SEMICOLON)
+    AST::VariableDeclaration.new(name, value)
+  end
+
+  def function_definition
+    eat(TokenKinds::FUNCTION)
+    name = identifier
+    params = parameters
+    body = block
+    AST::FunctionDefinition.new(name, params, body)
+  end
+
+  def class_definition
+    eat(TokenKinds::CLASS)
+
+    class_name = AST::Identifier.new(eat(TokenKinds::CLASS_NAME).value)
+
+    eat(TokenKinds::LBRACE)
+
+    members = Array.new
+
+    while [TokenKinds::PUBLIC, TokenKinds::PRIVATE].include?(
+      @current_token.type
+    )
+      is_public =
+        if @current_token.type == TokenKinds::PUBLIC
+          eat(TokenKinds::PUBLIC)
+          true
+        elsif @current_token.type == TokenKinds::PRIVATE
+          eat(TokenKinds::PRIVATE)
+          false
+        end
+
+      while !at_end && true
+        name = identifier
+        members << AST::Member.new(name, is_public)
+        if @current_token.type == TokenKinds::COMMA
+          eat(TokenKinds::COMMA)
+        else
+          break
+        end
+      end
+
+      eat(TokenKinds::SEMICOLON)
+    end
+
+    methods = Array.new
+    while @current_token.type == TokenKinds::FUNCTION
+      methods << function_definition
+    end
+
+    eat(TokenKinds::RBRACE)
+
+    AST::ClassDefinition.new(class_name, members, methods)
+  end
+
+  def conditional
+    branches = Array.new
+    eat(TokenKinds::IF)
+    condition = expression
+    block = self.block
+    branches << AST::Branch.new(condition, block)
+
+    while @current_token.type == TokenKinds::ELSEIF
+      eat(TokenKinds::ELSEIF)
+      condition = expression
+      block = self.block
+      branches << AST::Branch.new(condition, block)
+    end
+
+    if @current_token.type == TokenKinds::ELSE
+      eat(TokenKinds::ELSE)
+      block = self.block
+      branches << AST::Branch.new(AST::Boolean.new(true), block)
+    end
+
+    AST::Conditional.new(branches)
+  end
+
+  def parameters
+    params = Array.new
+    eat(TokenKinds::LPAREN)
+
+    while @current_token.type == TokenKinds::IDENTIFIER
+      params << identifier
+
+      if @current_token.type == TokenKinds::COMMA
+        eat(TokenKinds::COMMA)
+      else
+        break
+      end
+    end
+
+    eat(TokenKinds::RPAREN)
+
+    params
+  end
+
+  def block
+    statements = Array.new
+
+    eat(TokenKinds::LBRACE)
+    statements << statement until @current_token.type == TokenKinds::RBRACE
+    eat(TokenKinds::RBRACE)
+
+    AST::Block.new(statements)
+  end
+
+  def expression
+    expr = binary
+    if @current_token.type == TokenKinds::LPAREN
+      args = arguments
+      AST::FunctionCall.new(expr, args)
+    else
+      expr
+    end
+  end
+
+  private
+
+  def binary
+    left = comparison
+
+    if @current_token.type == TokenKinds::OPERATOR
+      operator = @current_token.value
+      advance
+      right = comparison
+      AST::Binary.new(operator, left, right)
+    else
+      left
+    end
+  end
+
+  def comparison
+    left = multiplication
+
+    if @current_token.type == TokenKinds::OPERATOR &&
+       %i[< > <= >=].include?(@current_token.type)
+      operator = @current_token.value
+      advance
+      right = multiplication
+      AST::Binary.new(operator, left, right)
+    else
+      left
+    end
+  end
+
+  def addition
+    left = multiplication
+
+    if @current_token.type == TokenKinds::OPERATOR &&
+       %i[+ -].include?(@current_token.value)
+      operator = @current_token.value
+      advance
+      right = multiplication
+      AST::Binary.new(operator, left, right)
+    else
+      left
+    end
+  end
+
+  def multiplication
+    left = primary
+
+    if @current_token.type == TokenKinds::OPERATOR &&
+       %i[* /].include?(@current_token.value)
+      operator = @current_token.value
+      advance
+      right = primary
+      AST::Binary.new(operator, left, right)
+    else
+      left
+    end
+  end
+
+  def primary
+    token = @current_token
+    case token.type
+    when TokenKinds::NULL
+      advance
+      AST::Null.new
+    when TokenKinds::BOOLEAN
+      advance
+      AST::Boolean.new(token.value)
+    when TokenKinds::NUMBER
+      advance
+      AST::Number.new(token.value)
+    when TokenKinds::STRING
+      advance
+      AST::String.new(token.value)
+    when TokenKinds::IDENTIFIER
+      identifier
+    when TokenKinds::LBRACKET
+      array
+    else
+      throw "Unexpected token #{token.type}"
+    end
+  end
+
+  def identifier
+    token = eat(TokenKinds::IDENTIFIER)
+    AST::Identifier.new(token.value)
+  end
+
+  def array
+    elements = Array.new
+    eat(TokenKinds::LBRACKET)
+
+    until @current_token.type == TokenKinds::RBRACKET
+      elements << expression
+
+      if @current_token.type == TokenKinds::COMMA
+        eat(TokenKinds::COMMA)
+      else
+        break
+      end
+    end
+
+    eat(TokenKinds::RBRACKET)
+
+    AST::Array.new(elements)
+  end
+
+  def arguments
+    args = Array.new
+    eat(TokenKinds::LPAREN)
+
+    until @current_token.type == TokenKinds::RPAREN
+      args << expression
+
+      if @current_token.type == TokenKinds::COMMA
+        eat(TokenKinds::COMMA)
+      else
+        break
+      end
+    end
+
+    eat(TokenKinds::RPAREN)
+
+    args
+  end
+
+  def eat(type)
+    token = @current_token
+    if token.type == type
+      advance
+      token
+    else
+      if token.nil?
+        throw "Unexpected #{token.type} - expected #{type}"
+      else
+        throw "Unexpected #{token.type} - expected #{type}"
+      end
+    end
+  end
+
+  def advance
+    @current_token = @lexer.get_token
+  end
+
+  def at_end
+    @current_token.type == TokenKinds::EOF
+  end
+end

lib/ahem/token.rb

@@ -0,0 +1,12 @@
+class Token
+  attr_reader :type, :value
+
+  def initialize(type, value = nil)
+    @type = type
+    @value = value
+  end
+
+  def ==(other)
+    @type == other.type && @value == other.value
+  end
+end

lib/ahem/token_kinds.rb

@@ -0,0 +1,28 @@
+module TokenKinds
+  BOOLEAN = :boolean
+  CLASS = :class
+  CLASS_NAME = :class_name
+  COMMA = :comma
+  DOT = :dot
+  ELSEIF = :elseif
+  ELSE = :else
+  EOF = :eof
+  EQUALS = :equals
+  FUNCTION = :function
+  IDENTIFIER = :identifier
+  IF = :if
+  LBRACE = :lbrace
+  LBRACKET = :lbracket
+  LPAREN = :lparen
+  LET = :let
+  NULL = :null
+  NUMBER = :number
+  OPERATOR = :operator
+  PRIVATE = :private
+  PUBLIC = :public
+  RBRACE = :rbrace
+  RBRACKET = :rbracket
+  RPAREN = :rparen
+  SEMICOLON = :semicolon
+  STRING = :string
+end

lib/ahem/version.rb

@@ -0,0 +1,3 @@
+module Ahem
+  VERSION = '0.1.0'
+end

spec/lexer_spec.rb

@@ -0,0 +1,125 @@
+RSpec.describe Lexer do
+  it 'lexes null' do
+    expect(Lexer.new('null').scan_all).to eq(
+      [Token.new(TokenKinds::NULL), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes booleans' do
+    expect(Lexer.new('true false').scan_all).to eq(
+      [
+        Token.new(TokenKinds::BOOLEAN, true),
+        Token.new(TokenKinds::BOOLEAN, false),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+
+  it 'lexes numbers' do
+    expect(Lexer.new('1 2.3').scan_all).to eq(
+      [
+        Token.new(TokenKinds::NUMBER, 1.0),
+        Token.new(TokenKinds::NUMBER, 2.3),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+
+  it 'lexes strings' do
+    expect(Lexer.new('"hello world"').scan_all).to eq(
+      [Token.new(TokenKinds::STRING, 'hello world'), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes operators' do
+    expect(Lexer.new('+-*/<<=>>= and or').scan_all).to eq(
+      [
+        Token.new(TokenKinds::OPERATOR, :+),
+        Token.new(TokenKinds::OPERATOR, :-),
+        Token.new(TokenKinds::OPERATOR, :*),
+        Token.new(TokenKinds::OPERATOR, :/),
+        Token.new(TokenKinds::OPERATOR, :<),
+        Token.new(TokenKinds::OPERATOR, :<=),
+        Token.new(TokenKinds::OPERATOR, :>),
+        Token.new(TokenKinds::OPERATOR, :>=),
+        Token.new(TokenKinds::OPERATOR, :and),
+        Token.new(TokenKinds::OPERATOR, :or),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+
+  it 'lexes punctuation' do
+    expect(Lexer.new('{}()[];,.').scan_all).to eq(
+      [
+        Token.new(TokenKinds::LBRACE),
+        Token.new(TokenKinds::RBRACE),
+        Token.new(TokenKinds::LPAREN),
+        Token.new(TokenKinds::RPAREN),
+        Token.new(TokenKinds::LBRACKET),
+        Token.new(TokenKinds::RBRACKET),
+        Token.new(TokenKinds::SEMICOLON),
+        Token.new(TokenKinds::COMMA),
+        Token.new(TokenKinds::DOT),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+
+  it 'lexes if elseif else' do
+    expect(Lexer.new('if elseif else').scan_all).to eq(
+      [
+        Token.new(TokenKinds::IF),
+        Token.new(TokenKinds::ELSEIF),
+        Token.new(TokenKinds::ELSE),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+
+  it 'lexes =' do
+    expect(Lexer.new('=').scan_all).to eq(
+      [Token.new(TokenKinds::EQUALS), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes let' do
+    expect(Lexer.new('let').scan_all).to eq(
+      [Token.new(TokenKinds::LET), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes identifiers' do
+    expect(Lexer.new('x').scan_all).to eq(
+      [Token.new(TokenKinds::IDENTIFIER, 'x'), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes function' do
+    expect(Lexer.new('function').scan_all).to eq(
+      [Token.new(TokenKinds::FUNCTION), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes class' do
+    expect(Lexer.new('class').scan_all).to eq(
+      [Token.new(TokenKinds::CLASS), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes class names' do
+    expect(Lexer.new('Class').scan_all).to eq(
+      [Token.new(TokenKinds::CLASS_NAME, 'Class'), Token.new(TokenKinds::EOF)]
+    )
+  end
+
+  it 'lexes public and private' do
+    expect(Lexer.new('public private').scan_all).to eq(
+      [
+        Token.new(TokenKinds::PUBLIC),
+        Token.new(TokenKinds::PRIVATE),
+        Token.new(TokenKinds::EOF)
+      ]
+    )
+  end
+end

spec/parser_spec.rb

@@ -0,0 +1,309 @@
+RSpec.describe Parser do
+  def parse(source)
+    Parser.new(Lexer.new(source)).parse
+  end
+
+  it 'parses null' do
+    expect(parse('null;')).to eq([AST::Null.new])
+  end
+
+  it 'parses booleans' do
+    expect(parse('true;')).to eq([AST::Boolean.new(true)])
+    expect(parse('false;')).to eq([AST::Boolean.new(false)])
+  end
+
+  it 'parses numbers' do
+    expect(parse('5;')).to eq([AST::Number.new(5.0)])
+  end
+
+  it 'parses strings' do
+    expect(parse('"hello world";')).to eq([AST::String.new('hello world')])
+  end
+
+  it 'parses addition' do
+    expect(parse('1 + 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::ADD,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+  end
+
+  it 'parses subtraction' do
+    expect(parse('1 - 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::SUBTRACT,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+  end
+
+  it 'parses multiplication' do
+    expect(parse('1 * 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::MULTIPLY,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+  end
+
+  it 'parses division' do
+    expect(parse('1 / 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::DIVIDE,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+  end
+
+  it 'gives multiplication higher precedence than addition' do
+    expect(parse('1 + 2 * 3;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::ADD,
+          AST::Number.new(1.0),
+          AST::Binary.new(
+            AST::Operators::MULTIPLY,
+            AST::Number.new(2.0),
+            AST::Number.new(3.0)
+          )
+        )
+      ]
+    )
+  end
+
+  it 'gives multiplication higher precedence than subtraction' do
+    expect(parse('1 - 2 / 3;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::SUBTRACT,
+          AST::Number.new(1.0),
+          AST::Binary.new(
+            AST::Operators::DIVIDE,
+            AST::Number.new(2.0),
+            AST::Number.new(3.0)
+          )
+        )
+      ]
+    )
+  end
+
+  it 'parses if statement' do
+    expect(parse('if true { "true"; }')).to eq(
+      [
+        AST::Conditional.new(
+          [
+            AST::Branch.new(
+              AST::Boolean.new(true),
+              AST::Block.new([AST::String.new('true')])
+            )
+          ]
+        )
+      ]
+    )
+  end
+
+  it 'parses if else statement' do
+    expect(parse('if true { "true"; } else { "false"; }')).to eq(
+      [
+        AST::Conditional.new(
+          [
+            AST::Branch.new(
+              AST::Boolean.new(true),
+              AST::Block.new([AST::String.new('true')])
+            ),
+            AST::Branch.new(
+              AST::Boolean.new(true),
+              AST::Block.new([AST::String.new('false')])
+            )
+          ]
+        )
+      ]
+    )
+  end
+
+  it 'parses if elseif else statement' do
+    expect(
+      parse('if true { "true"; } elseif false { "false"; } else { "neither"; }')
+    ).to eq(
+      [
+        AST::Conditional.new(
+          [
+            AST::Branch.new(
+              AST::Boolean.new(true),
+              AST::Block.new([AST::String.new('true')])
+            ),
+            AST::Branch.new(
+              AST::Boolean.new(false),
+              AST::Block.new([AST::String.new('false')])
+            ),
+            AST::Branch.new(
+              AST::Boolean.new(true),
+              AST::Block.new([AST::String.new('neither')])
+            )
+          ]
+        )
+      ]
+    )
+  end
+
+  it 'parses comparisons' do
+    expect(parse('1 < 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::LESS_THAN,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+    expect(parse('1 > 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::GREATER_THAN,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+    expect(parse('1 <= 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::LESS_THAN_OR_EQUAL,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+    expect(parse('1 >= 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::GREATER_THAN_OR_EQUAL,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+    expect(parse('1 or 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::OR,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+    expect(parse('1 and 2;')).to eq(
+      [
+        AST::Binary.new(
+          AST::Operators::AND,
+          AST::Number.new(1.0),
+          AST::Number.new(2.0)
+        )
+      ]
+    )
+  end
+
+  it 'parses identifier' do
+    expect(parse('x;')).to eq([AST::Identifier.new('x')])
+  end
+
+  it 'parses variable declaration' do
+    expect(parse('let x = 1;')).to eq(
+      [
+        AST::VariableDeclaration.new(
+          AST::Identifier.new('x'),
+          AST::Number.new(1.0)
+        )
+      ]
+    )
+  end
+
+  it 'parses function definition' do
+    result = [
+      AST::FunctionDefinition.new(
+        AST::Identifier.new('add_one'),
+        [AST::Identifier.new('x')],
+        AST::Block.new(
+          [
+            AST::Binary.new(
+              AST::Operators::ADD,
+              AST::Identifier.new('x'),
+              AST::Number.new(1.0)
+            )
+          ]
+        )
+      )
+    ]
+
+    expect(parse('function add_one(x) { x + 1; }')).to eq(result)
+    expect(parse('function add_one(x,) { x + 1; }')).to eq(result)
+  end
+
+  it 'parses function call' do
+    result = [
+      AST::FunctionCall.new(
+        AST::Identifier.new('func'),
+        [AST::Number.new(1.0), AST::Number.new(2.0)]
+      )
+    ]
+
+    expect(parse('func(1, 2);')).to eq(result)
+    expect(parse('func(1, 2,);')).to eq(result)
+  end
+
+  it 'parses array literal' do
+    result = [
+      AST::Array.new(
+        [AST::Number.new(1.0), AST::Number.new(2.0), AST::Number.new(3.0)]
+      )
+    ]
+
+    expect(parse('[1, 2, 3];')).to eq(result)
+    expect(parse('[1, 2, 3,];')).to eq(result)
+  end
+
+  it 'parses a class definition do' do
+    expect(
+      parse(<<~CLASS)
+          class Class {
+            public foo, bar;
+            private baz;
+            function method() {
+              "method";
+            }
+          }
+        CLASS
+    ).to eq(
+      [
+        AST::ClassDefinition.new(
+          AST::Identifier.new('Class'),
+          [
+            AST::Member.new(AST::Identifier.new('foo'), true),
+            AST::Member.new(AST::Identifier.new('bar'), true),
+            AST::Member.new(AST::Identifier.new('baz'), false)
+          ],
+          [
+            AST::FunctionDefinition.new(
+              AST::Identifier.new('method'),
+              [],
+              AST::Block.new([AST::String.new('method')])
+            )
+          ]
+        )
+      ]
+    )
+  end
+end

spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'ahem'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path =
+    '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end