loxby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c24f85fecb8840b0c2b6331b6b4dda6c5a4899e830d81f52ed6ffa12065b432
+  data.tar.gz: 3b694bcad715f645c52501d192944c207932d71909189f0b9f2dd0eae9e3d392
+SHA512:
+  metadata.gz: 14167ca0449fa15e8b5eba780ab63af4d9b702c9b762c8bb3d2724840549481a25ba1806a4d5702e8ed0b925518872a1ec72ec17db0bc7f8170011d1891e9903
+  data.tar.gz: 6b8366382f8c51bffdfe71802a0b551aee4938e0880c878012778c8508094544a9f1c02ca1f7dde57dcc1e03919545387b652877dc2ea38266c8422d6ba89b14

data/.github/workflows/gem-push.yml

@@ -0,0 +1,44 @@
+name: Ruby Gem
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby 3.1
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.1.3
+
+    - name: Publish to GPR
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
+      env:
+        GEM_HOST_API_KEY: "Bearer ${{secrets.GITHUB_TOKEN}}"
+        OWNER: ${{ github.repository_owner }}
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        chmod +x bin/loxby
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1.3
+
+Metrics/ClassLength:
+  Enabled: false
+
+Lint/BooleanSymbol:
+  Enabled: false

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    loxby (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    parallel (1.24.0)
+    parser (3.3.2.0)
+      ast (~> 2.4.1)
+      racc
+    racc (1.8.0)
+    rainbow (3.1.1)
+    regexp_parser (2.9.2)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
+    rubocop (1.64.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    ruby-progressbar (1.13.0)
+    strscan (3.1.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  x64-mingw-ucrt
+
+DEPENDENCIES
+  loxby!
+  rubocop
+  strscan
+
+BUNDLED WITH
+   2.5.10

data/README.md

@@ -0,0 +1,13 @@
+# Loxby
+*A Lox interpreter written in Ruby*
+
+Loxby is written following the first half of Robert Nystrom's wonderful web-format book [Crafting Interpreters](https://www.craftinginterpreters.com), adapting the Java code to modern Ruby. This project is intended to explore what elegant object-oriented code can look like and accomplish.
+
+## Usage
+1. `gem install loxby` or `gem 'loxby'`
+2. `loxby [filename]` to run a file or `loxby` to run in REPL mode
+3. To run the interpreter from Ruby:
+    ```ruby
+    require 'loxby/runner'
+    Lox::Runner.new(ARGV, $stdout, $stderr)
+    ```

data/bin/loxby

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'loxby/runner'
+
+# Start interpreter when run as script
+Lox::Runner.new.run(ARGV) if __FILE__ == $PROGRAM_NAME

data/lib/loxby/core.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'scanner'
+require_relative 'parser'
+require_relative 'interpreter'
+require_relative 'helpers/token_type'
+
+# Lox interpreter.
+# Each interpreter keeps track of its own
+# environment, including variable and
+# function scope.
+class Lox
+  attr_reader :errored, :interpreter
+
+  def initialize
+    @errored = false
+    @errored_in_runtime = false
+    @interpreter = Interpreter.new(self) # Make static so REPL sessions reuse it
+  end
+
+  # Run from file
+  def run_file(path)
+    if File.exist? path
+      run File.read(path)
+    else
+      report(0, '', "No such file: '#{path}'")
+    end
+    exit(65) if @errored # Don't execute malformed code
+    exit(70) if @errored_in_runtime
+  end
+
+  # Run interactively
+  def run_prompt
+    loop do
+      print '> '
+      line = gets
+      break unless line # Trap eof (Ctrl+D unix, Ctrl+Z win)
+
+      result = run(line)
+      puts "=> #{@interpreter.lox_obj_to_str result}" unless @errored
+      @errored = false # Reset so a mistake doesn't kill the repl
+    end
+  end
+
+  # Run a string
+  def run(source)
+    tokens = Scanner.new(source, self).scan_tokens
+    parser = Parser.new(tokens, self)
+    statements = parser.parse
+    return if @errored
+
+    @interpreter.interpret statements
+  end
+
+  def error(line, message)
+    if line.is_a? Lox::Token
+      # Parse/runtime error
+      where = line.type == :eof ? 'end' : "'#{line.lexeme}'"
+      report(line.line, " at #{where}", message)
+    else
+      # Scan error
+      report(line, '', message)
+    end
+  end
+
+  # rubocop:disable Style/StderrPuts
+
+  def runtime_error(err)
+    $stderr.puts err.message
+    $stderr.puts "[line #{err.token.line}]"
+    @errored_in_runtime = true
+  end
+
+  private
+
+  def report(line, where, message)
+    $stderr.puts "[line #{line}] Error#{where}: #{message}"
+    @errored = true
+  end
+end
+# rubocop:enable Style/StderrPuts

data/lib/loxby/helpers/ast.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../visitors/base'
+
+class String # rubocop:disable Style/Documentation
+  def to_camel_case
+    to_s.split(/[-_]/).map(&:capitalize).join('')
+  end
+end
+
+class Symbol # rubocop:disable Style/Documentation
+  def to_camel_case
+    to_s.to_camel_case.to_sym
+  end
+end
+
+class Lox
+  # Interface:
+  #   Lox::AST.define_ast(
+  #     "ASTBaseClass",
+  #     {
+  #       :ast_type => [[:field_one_type, :field_one_name], [:field_two_type, :field_two_name]],
+  #       :other_ast_type => [[:field_type, :field_name]]
+  #     }
+  #   )
+  #
+  # This defines Lox::AST::ASTBaseClass, which ::AstType and ::OtherAstType descend from
+  # and are scoped under. It also defines the Visitor pattern: AstType defines #accept(visitor),
+  # which calls `visitor.visit_ast_type(self)`
+  module AST
+    module_function
+
+    def define_ast(base_name, types)
+      base_class = Class.new
+      base_class.include Visitable
+      # Define boilerplate visitor methods
+      Visitor.define_types(base_name, types.keys)
+      # Dynamically create subclasses for each AST type
+      types.each do |class_name, fields|
+        define_type(base_class, base_name, class_name, fields)
+      end
+
+      define_class base_name.to_camel_case, base_class
+    end
+
+    def define_type(base_class, base_class_name, subtype_name, fields) # rubocop:disable Metrics/MethodLength
+      subtype = Class.new(base_class)
+      parameters = fields.map { _1[1].to_s }
+
+      subtype.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        include Visitable # Visitor pattern
+        attr_reader #{parameters.map { ":#{_1}" }.join(', ')}
+        def initialize(#{parameters.map { "#{_1}:" }.join(', ')})
+          #{parameters.map { "@#{_1}" }.join(', ')} = #{parameters.join ', '}
+        end
+
+        # Dynamically generated for visitor pattern.
+        # Expects visitor to define #visit_#{subtype_name}
+        def accept(visitor)
+          visitor.visit_#{subtype_name}_#{base_class_name}(self)
+        end
+      RUBY
+
+      define_class(subtype_name.to_camel_case, subtype, base_class:)
+    end
+
+    def define_class(class_name, klass, base_class: Lox::AST)
+      base_class.const_set class_name, klass
+    end
+  end
+end
+
+Lox::AST.define_ast(
+  :expression,
+  {
+    assign: [%i[token name], %i[expr value]],
+    binary: [%i[expr left], %i[token operator], %i[expr right]],
+    ternary: [%i[expr left], %i[token left_operator], %i[expr center], %i[token right_operator], %i[expr right]],
+    grouping: [%i[expr expression]],
+    literal: [%i[object value]],
+    unary: [%i[token operator], %i[expr right]],
+    variable: [%i[token name]]
+  }
+)
+
+Lox::AST.define_ast(
+  :statement,
+  {
+    block: [%i[stmt_list statements]],
+    expression: [%i[expr expression]],
+    print: [%i[expr expression]],
+    var: [%i[token name], %i[expr initializer]]
+  }
+)

data/lib/loxby/helpers/environment.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+class Lox
+  # Lox::Environment stores namespace for
+  # a Lox interpreter. Environments can be
+  # nested (for scope).
+  class Environment
+    def initialize(enclosing = nil)
+      @enclosing = enclosing
+      @values = {}
+    end
+
+    def undefined_variable(name)
+      Lox::RunError.new(name, "Undefined variable '#{name.lexeme}'")
+    end
+
+    def []=(name, value)
+      @values[name.lexeme] = value
+    end
+
+    def exists?(name)
+      @values.keys.member? name.lexeme
+    end
+
+    def [](name)
+      if exists? name
+        @values[name.lexeme]
+      elsif @enclosing
+        @enclosing[name]
+      else
+        raise undefined_variable(name)
+      end
+    end
+
+    def assign(name, value)
+      if exists? name
+        self[name] = value
+      elsif @enclosing
+        @enclosing.assign(name, value)
+      else
+        raise undefined_variable(name)
+      end
+    end
+  end
+end

data/lib/loxby/helpers/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Lox
+  class ParseError < RuntimeError; end
+
+  class RunError < RuntimeError # rubocop:disable Style/Documentation
+    attr_reader :token
+
+    def initialize(token, message)
+      super(message)
+      @token = token
+    end
+  end
+
+  class DividedByZeroError < RunError; end
+end

data/lib/loxby/helpers/token_type.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Lox
+  class Token
+    TOKENS = [
+      # Single-character tokens.
+      :left_paren, :right_paren, :left_brace, :right_brace,
+      :comma, :dot, :minus, :plus, :semicolon, :slash, :star,
+      :question, :colon,
+
+      # 1-2 character tokens.
+      :bang, :bang_equal,
+      :equal, :equal_equal,
+      :greater, :greater_equal,
+      :less, :less_equal,
+
+      # Literals.
+      :identifier, :string, :number,
+
+      # Keywords.
+      :and, :class, :else, :false, :fun, :for, :if, :nil, :or,
+      :print, :return, :super, :this, :true, :var, :while,
+
+      :eof
+    ].freeze
+    SINGLE_TOKENS = TOKENS.zip('(){},.-+;/*'.split('')).to_h
+
+    attr_reader :type, :lexeme, :literal, :line
+
+    def initialize(type, lexeme, literal, line)
+      @type = type
+      @lexeme = lexeme
+      @literal = literal
+      @line = line
+    end
+
+    def to_s = "#{type} #{lexeme} #{literal}"
+    def inspect = "#<Lox::Token #{self}>"
+  end
+end

data/lib/loxby/interpreter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/environment'
+require_relative 'helpers/errors'
+require_relative 'visitors/base'
+
+# Interpreter class. Walks the AST using
+# the Visitor pattern.
+class Interpreter < Visitor
+  def initialize(process) # rubocop:disable Lint/MissingSuper
+    @process = process
+    @environment = Lox::Environment.new
+  end
+
+  def interpret(statements)
+    result = nil
+    statements.each { result = lox_eval(_1) }
+    result
+  rescue Lox::RunError => e
+    @process.runtime_error e
+  end
+
+  def lox_eval(expr)
+    expr.accept self
+  end
+
+  # Lox's definition of truthiness follows
+  # Ruby's by definition. This does nothing.
+  def truthy?(obj)
+    obj
+  end
+
+  def ensure_number(operator, *objs)
+    raise Lox::RunError.new(operator, 'Operand must be a number.') unless objs.all? { _1.is_a?(Float) }
+  end
+
+  def lox_obj_to_str(obj)
+    case obj
+    when nil
+      'nil'
+    when Float
+      obj.to_s[-2..] == '.0' ? obj.to_s[0...-2] : obj.to_s
+    else
+      obj.to_s
+    end
+  end
+
+  def visit_expression_statement(statement)
+    lox_eval statement.expression
+  end
+
+  def visit_print_statement(statement)
+    value = lox_eval statement.expression
+    puts lox_obj_to_str(value)
+  end
+
+  def visit_var_statement(statement)
+    value = statement.initializer ? lox_eval(statement.initializer) : nil
+    @environment[statement.name] = value
+  end
+
+  def visit_variable_expression(expr)
+    @environment[expr.name]
+  end
+
+  def visit_assign_expression(expr)
+    value = lox_eval expr.value
+    @environment.assign expr.name, value
+    value
+  end
+
+  def visit_block_statement(statement)
+    execute_block(statement.statements, Lox::Environment.new(@environment))
+  end
+
+  def execute_block(statements, environment)
+    previous = @environment
+    @environment = environment
+    statements.each { lox_eval _1 }
+  ensure
+    @environment = previous
+  end
+
+  # Leaves of the AST. The scanner picks
+  # out these values for us beforehand.
+  def visit_literal_expression(expr)
+    expr.value
+  end
+
+  def visit_grouping_expression(expr)
+    lox_eval expr
+  end
+
+  def visit_unary_expression(expr)
+    right = lox_eval(expr.right)
+
+    case expr.operator.type
+    when :minus
+      ensure_number(expr.operator, right)
+      -right.to_f
+    when :bang
+      truthy? right
+    end
+  end
+
+  def visit_binary_expression(expr) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/AbcSize
+    left = lox_eval expr.left
+    right = lox_eval expr.right
+    case expr.operator.type
+    when :minus
+      ensure_number(expr.operator, left, right)
+      left.to_f - right.to_f
+    when :slash
+      raise Lox::DividedByZeroError.new(expr.operator, 'Cannot divide by zero.') if right == 0.0
+
+      ensure_number(expr.operator, left, right)
+      left.to_f / right
+    when :star
+      ensure_number(expr.operator, left, right)
+      left.to_f * right.to_f
+    when :plus
+      unless (left.is_a?(Float) || left.is_a?(String)) && left.instance_of?(right.class)
+        raise Lox::RunError.new(expr.operator, 'Operands must be two numbers or two strings.')
+      end
+
+      left + right
+    when :greater
+      ensure_number(expr.operator, left, right)
+      left.to_f > right.to_f
+    when :greater_equal
+      ensure_number(expr.operator, left, right)
+      left.to_f >= right.to_f
+    when :less
+      ensure_number(expr.operator, left, right)
+      left.to_f < right.to_f
+    when :less_equal
+      ensure_number(expr.operator, left, right)
+      left.to_f <= right.to_f
+    when :bang_equal
+      left != right
+    when :equal_equal
+      left == right
+    when :comma
+      right
+    end
+  end
+
+  def visit_ternary_expression(expr)
+    left = lox_eval expr.left
+
+    left ? lox_eval(expr.center) : lox_eval(expr.right)
+  end
+end

data/lib/loxby/parser.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/ast'
+require_relative 'helpers/errors'
+
+class Lox
+  # Lox::Parser converts a list of tokens
+  # from Lox::Scanner to a syntax tree.
+  # This tree can be interacted with using
+  # the Visitor pattern. (See the Visitor
+  # class in visitors/base.rb.)
+  class Parser
+    def initialize(tokens, interpreter)
+      @tokens = tokens
+      @interpreter = interpreter
+      # Variables for parsing
+      @current = 0
+    end
+
+    def parse
+      statements = []
+      statements << declaration until end_of_input?
+      statements
+    end
+
+    def declaration
+      if matches?(:var)
+        var_declaration
+      else
+        statement
+      end
+    rescue Lox::ParseError
+      synchronize
+      nil
+    end
+
+    def var_declaration
+      name = consume :identifier, 'Expect variable name.'
+      initializer = matches?(:equal) ? expression : nil
+      consume :semicolon, "Expect ';' after variable declaration."
+      Lox::AST::Statement::Var.new(name:, initializer:)
+    end
+
+    def statement
+      if matches? :print
+        print_statement
+      elsif matches? :left_brace
+        Lox::AST::Statement::Block.new(statements: block)
+      else
+        expression_statement
+      end
+    end
+
+    def block
+      statements = []
+      statements << declaration until check(:right_brace) || end_of_input?
+      consume :right_brace, "Expect '}' after block."
+      statements
+    end
+
+    def print_statement
+      value = expression_list
+      consume :semicolon, "Expect ';' after value."
+      Lox::AST::Statement::Print.new(expression: value)
+    end
+
+    def expression_statement
+      expr = expression_list
+      consume :semicolon, "Expect ';' after expression."
+      Lox::AST::Statement::Expression.new(expression: expr)
+    end
+
+    def expression_list
+      expr = conditional
+
+      while matches? :comma
+        operator = previous
+        right = conditional
+        expr = Lox::AST::Expression::Binary.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
+    # Ternary operator
+    def conditional
+      expr = expression
+
+      if matches? :question
+        left_operator = previous
+        center = check(:colon) ? Lox::AST::Expression::Literal.new(value: nil) : expression_list
+        consume :colon, "Expect ':' after expression (ternary operator)."
+        right_operator = previous
+        right = conditional # Recurse, right-associative
+        expr = Lox::AST::Expression::Ternary.new(left: expr, left_operator:, center:, right_operator:, right:)
+      end
+
+      expr
+    end
+
+    def expression
+      assignment
+    end
+
+    def assignment # rubocop:disable Metrics/MethodLength
+      expr = equality
+
+      if matches? :equal
+        equals = previous
+        value = assignment
+
+        if expr.is_a? Lox::AST::Expression::Variable
+          name = expr.name
+          return Lox::AST::Expression::Assign.new(name:, value:)
+        end
+
+        error equals, 'Invalid assignment target.'
+      end
+
+      expr
+    end
+
+    def equality
+      expr = comparison
+      while matches?(:bang_equal, :equal_equal)
+        operator = previous
+        right = comparison
+        # Compose (equality is left-associative)
+        expr = Lox::AST::Expression::Binary.new(left: expr, operator:, right:)
+      end
+      expr
+    end
+
+    def comparison
+      expr = term
+
+      while matches?(:greater, :greater_equal, :less, :less_equal)
+        operator = previous
+        right = term
+        expr = Lox::AST::Expression::Binary.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
+    def term
+      expr = factor
+
+      while matches?(:minus, :plus)
+        operator = previous
+        right = factor
+        expr = Lox::AST::Expression::Binary.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
+    def factor
+      expr = unary
+
+      while matches?(:slash, :star)
+        operator = previous
+        right = unary
+        expr = Lox::AST::Expression::Binary.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
+    def unary
+      # Unary operators are right-associative, so we match
+      # first, then recurse.
+      if matches?(:bang, :minus)
+        operator = previous
+        right = unary
+
+        Lox::AST::Expression::Unary.new(operator:, right:)
+      else
+        primary
+      end
+    end
+
+    def primary # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      if matches? :false
+        Lox::AST::Expression::Literal.new(value: false)
+      elsif matches? :true
+        Lox::AST::Expression::Literal.new(value: true)
+      elsif matches? :nil
+        Lox::AST::Expression::Literal.new(value: nil)
+      elsif matches? :number, :string
+        Lox::AST::Expression::Literal.new(value: previous.literal)
+      elsif matches? :identifier
+        Lox::AST::Expression::Variable.new(name: previous)
+      elsif matches? :left_paren
+        expr = expression_list
+        consume :right_paren, "Expect ')' after expression."
+        Lox::AST::Expression::Grouping.new(expression: expr)
+      # Error productions--binary operator without left operand
+      elsif matches? :comma
+        err = error(previous, "Expect expression before ',' operator.")
+        conditional # Parse and throw away
+        raise err
+      elsif matches? :question
+        err = error(previous, 'Expect expression before ternary operator.')
+        expression_list
+        consume :colon, "Expect ':' after '?' (ternary operator)."
+        conditional
+        raise err
+      elsif matches? :bang_equal, :equal_equal
+        err = error(previous, "Expect value before '#{previous.lexeme}'.")
+        comparison
+        raise err
+      elsif matches? :greater, :greater_equal, :less, :less_equal
+        err = error(previous, "Expect value before '#{previous.lexeme}'.")
+        term
+        raise err
+      elsif matches? :plus
+        err = error(previous, "Expect value before '+'.")
+        factor
+        raise err
+      elsif matches? :slash, :star
+        err = error(previous, "Expect value before '#{previous.lexeme}'.")
+        unary
+        raise err
+      # Base case--no match.
+      else
+        raise error(peek, 'Expect expression.')
+      end
+    end
+
+    private
+
+    def consume(type, message)
+      return advance if check(type)
+
+      # Call #error to report the error to the interpreter, and
+      # raise the error in prep for synchronizing (panic mode).
+      raise error(peek, message)
+    end
+
+    def error(token, message)
+      @interpreter.error(token, message)
+      Lox::ParseError.new
+    end
+
+    # Synchronize the parser (i.e. panic mode).
+    # We're skipping possibly erroneous tokens
+    # to prevent cascading errors.
+    def synchronize
+      advance
+
+      until end_of_input?
+        return if previous.type == :semicolon
+        return if peek.type == :return
+
+        advance
+      end
+    end
+
+    # Checks if current token is a given type, consuming
+    # it if it is.
+    def matches?(*types)
+      # Array#any? guarantees short-circuit evaluation.
+      # #advance returns a Token/Expression, which is truthy.
+      # `advance if check(type)` is truthy when `check(type)`
+      # is.
+      types.any? { |type| advance if check(type) }
+    end
+
+    # Checks if current token is a given type. Does not
+    # consume it.
+    def check(type)
+      peek.type == type && !end_of_input?
+    end
+
+    def advance
+      @current += 1 unless end_of_input?
+      previous
+    end
+
+    def end_of_input?
+      peek.type == :eof
+    end
+
+    def peek
+      @tokens[@current]
+    end
+
+    def previous
+      @tokens[@current - 1]
+    end
+  end
+end

data/lib/loxby/runner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../loxby'
+
+class Lox
+  # Lox::Runner is the interactive runner
+  # which kickstarts the interpreter.
+  # An instance is created when loxby is
+  # initialized from the command line.
+  class Runner
+    def initialize(out = $stdout, err = $stderr)
+      trap('SIGINT') { exit } # Exit cleanly on Ctrl-C
+      @interpreter = Lox.new
+      @out = out
+      @err = err
+    end
+
+    def run(args)
+      if args.size > 1
+        @out.puts 'Usage: loxby.rb [script]'
+        exit 64
+      elsif args.size == 1
+        @interpreter.run_file args[0]
+      else
+        @interpreter.run_prompt # Run interactively
+      end
+    end
+  end
+end

data/lib/loxby/scanner.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/token_type'
+
+class Lox
+  class Scanner
+    EXPRESSIONS = {
+      whitespace: /\s/,
+      number_literal: /\d/,
+      identifier: /[a-zA-Z_]/
+    }.freeze
+    KEYWORDS = %w[and class else false for fun if nil or print return super this true var while]
+               .map { [_1, _1.to_sym] }
+               .to_h
+
+    attr_accessor :line
+
+    def initialize(source, interpreter)
+      @source = source
+      @tokens = []
+      @interpreter = interpreter
+      # Variables for scanning
+      @start = 0
+      @current = 0
+      @line = 1
+    end
+
+    def scan_tokens
+      until end_of_source?
+        # Beginnning of next lexeme
+        @start = @current
+        scan_token
+      end
+
+      # Implicitly return @tokens
+      @tokens << Lox::Token.new(:eof, "", nil, @line)
+    end
+
+    def scan_token # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      character = advance_character
+
+      case character
+      # Single-character tokens
+      when '('
+        add_token :left_paren
+      when ')'
+        add_token :right_paren
+      when '{'
+        add_token :left_brace
+      when '}'
+        add_token :right_brace
+      when ','
+        add_token :comma
+      when '.'
+        add_token :dot
+      when '-'
+        add_token :minus
+      when '+'
+        add_token :plus
+      when ';'
+        add_token :semicolon
+      when '*'
+        add_token :star
+      when '?'
+        add_token :question
+      when ':'
+        add_token :colon
+      # 1-2 character tokens
+      when '!'
+        add_token match('=') ? :bang_equal : :bang
+      when '='
+        add_token match('=') ? :equal_equal : :equal
+      when '<'
+        add_token match('=') ? :less_equal : :less
+      when '>'
+        add_token match('=') ? :greater_equal : :greater
+      when '/'
+        # '/' is division, '//' is comment, '/* ... */'
+        # is block comment. Needs special care.
+        if match('/') # comment line
+          advance_character until peek == "\n" || end_of_source?
+        elsif match('*') # block comment
+          scan_block_comment
+        else
+          add_token :slash
+        end
+      # Whitespace
+      when "\n"
+        @line += 1
+      when EXPRESSIONS[:whitespace]
+      # Literals
+      when '"'
+        scan_string
+      when EXPRESSIONS[:number_literal]
+        scan_number
+      # Keywords and identifiers
+      when EXPRESSIONS[:identifier]
+        scan_identifier
+      else
+        # Unknown character
+        @interpreter.error(@line, 'Unexpected character.')
+      end
+    end
+
+    def scan_block_comment # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      advance_character until (peek == '*' && peek_next == '/') || (peek == '/' && peek_next == '*') || end_of_source?
+
+      if end_of_source? || peek_next == "\0"
+        @interpreter.error(line, 'Unterminated block comment.')
+        return
+      elsif peek == '/' && peek_next == '*'
+        # Nested block comment. Skip opening characters
+        match '/'
+        match '*'
+        scan_block_comment # Skip nested comment
+        advance_character until (peek == '*' && peek_next == '/') || (peek == '/' && peek_next == '*') || end_of_source?
+      end
+
+      # Skip closing characters
+      match '*'
+      match '/'
+    end
+
+    def scan_string # rubocop:disable Metrics/MethodLength
+      until peek == '"' || end_of_source?
+        @line += 1 if peek == "\n"
+        advance_character
+      end
+
+      if end_of_source?
+        @interpreter.error(line, 'Unterminated string.')
+        return
+      end
+
+      # Skip closing "
+      advance_character
+
+      # Trim quotes around literal
+      value = @source[(@start + 1)...(@current - 1)]
+      add_token :string, value
+    end
+
+    def scan_number
+      advance_character while peek =~ EXPRESSIONS[:number_literal]
+
+      # Check for decimal
+      if peek == '.' && peek_next =~ EXPRESSIONS[:number_literal]
+        # Consume decimal point
+        advance_character
+        advance_character while peek =~ EXPRESSIONS[:number_literal]
+      end
+
+      add_token :number, @source[@start...@current].to_f
+    end
+
+    def scan_identifier
+      advance_character while peek =~ Regexp.union(EXPRESSIONS[:identifier], /\d/)
+      text = @source[@start...@current]
+      add_token(KEYWORDS[text] || :identifier)
+    end
+
+    def advance_character
+      character = @source[@current]
+      @current += 1
+      character
+    end
+
+    def add_token(type, literal = nil)
+      text = @source[@start...@current]
+      @tokens << Lox::Token.new(type, text, literal, @line)
+    end
+
+    def match(expected)
+      return false unless @source[@current] == expected || end_of_source?
+
+      @current += 1
+      true
+    end
+
+    def end_of_source? = @current >= @source.size
+
+    # 1-character lookahead
+    def peek
+      end_of_source? ? "\0" : @source[@current]
+    end
+
+    # 2-character lookahead
+    def peek_next
+      (@current + 1) > @source.size ? "\0" : @source[@current + 1]
+    end
+  end
+end

data/lib/loxby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Loxby
+  VERSION = '0.0.2'
+end

data/lib/loxby/visitors/ast_printer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class ASTPrinter < Visitor
+  def print(expression)
+    expression.accept self
+  end
+
+  def parenthesize(*args)
+    str = "(#{args[0]}"
+    args[1..].each do |expr|
+      str << " #{expr.accept self}"
+    end
+    str << ')'
+  end
+
+  def visit_binary_expression(expr)
+    parenthesize expr.operator.lexeme, expr.left, expr.right
+  end
+
+  def visit_ternary_expression(expr)
+    parenthesize expr.left_operator.lexeme + expr.right_operator.lexeme, expr.left, expr.center, expr.right
+  end
+
+  def visit_grouping_expression(expr)
+    parenthesize 'group', expr.expression
+  end
+
+  def visit_literal_expression(expr)
+    expr.value.nil? ? 'nil' : expr.value.to_s
+  end
+
+  def visit_unary_expression(expr)
+    parenthesize expr.operator.lexeme, expr.right
+  end
+end

data/lib/loxby/visitors/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Visitable adds #accept, the only
+# method required to implement the
+# visitor pattern on a class.
+# To use the visitor pattern,
+# `include Visitable` to your class
+# and subclass `Visitor` to implement
+# visitors.
+module Visitable
+  def accept(visitor)
+    raise NotImplementedError, "#{self.class} has not implemented #accept"
+  end
+end
+
+# Base visitor class for visitor pattern.
+# See Visitable.
+class Visitor
+  def self.define_types(base_type, subtypes)
+    subtypes.each do |subtype|
+      method_name = "visit_#{subtype}_#{base_type}"
+      define_method(method_name.to_sym) do |_|
+        raise NotImplementedError, "#{self.class} has not implemented ##{method_name}"
+      end
+    end
+  end
+end

data/lib/loxby/visitors/rpn_converter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class RPNConverter < Visitor
+  def print(expr)
+    expr.accept self
+  end
+
+  def visit_binary_expression(expr)
+    "#{expr.left.accept self} #{expr.right.accept self} #{expr.operator.lexeme}"
+  end
+
+  def visit_grouping_expression(expr)
+    expr.accept self
+  end
+
+  def visit_literal_expression(expr)
+    expr.value.to_s
+  end
+
+  def visit_unary_expression(expr)
+    "#{expr.right.accept self} #{expr.operator.lexeme}"
+  end
+end

data/lib/loxby.rb

@@ -0,0 +1,5 @@
+# Lox interpreter in Ruby
+# frozen_string_literal: true
+
+require_relative 'loxby/core'
+require_relative 'loxby/version'

data/loxby.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'lib/loxby/version'
+
+Gem::Specification.new do |s|
+  s.name = 'loxby'
+  s.version = Loxby::VERSION
+  s.authors = ['Paul Hartman']
+  s.email = ['real.paul.hartman@gmail.com']
+
+  s.summary = 'A Lox interpreter written in Ruby'
+  s.description = 'Loxby is written following the first ' \
+  "half of Robert Nystrom's wonderful web-format book " \
+  '[Crafting Interpreters](https://www.craftinginterpreters.com), ' \
+  'adapting the Java code to modern Ruby. This project is ' \
+  'intended to explore what elegant object-oriented code ' \
+  'can look like and accomplish.'
+  s.homepage = 'https://github.com/paul-c-hartman/loxby'
+  s.license = 'MIT'
+  s.required_ruby_version = Gem::Requirement.new('>= 3.1.0') # Shorthand hash syntax
+
+  s.metadata['homepage_uri'] = s.homepage
+  s.metadata['source_code_uri'] = s.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # `git ls-files -z` loads the files in the gem which git is tracking.
+  s.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { _1.match %r{^(test|spec|features)/} } - %w[Gemfile Gemfile.lock.rubocop.yml]
+  end
+  s.bindir = 'bin'
+  s.executables = %w[loxby]
+  s.require_paths = %w[lib]
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: loxby
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Paul Hartman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-06-12 00:00:00.000000000 Z
+dependencies: []
+description: Loxby is written following the first half of Robert Nystrom's wonderful
+  web-format book [Crafting Interpreters](https://www.craftinginterpreters.com), adapting
+  the Java code to modern Ruby. This project is intended to explore what elegant object-oriented
+  code can look like and accomplish.
+email:
+- real.paul.hartman@gmail.com
+executables:
+- loxby
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/gem-push.yml"
+- ".rubocop.yml"
+- Gemfile.lock
+- README.md
+- bin/loxby
+- lib/loxby.rb
+- lib/loxby/core.rb
+- lib/loxby/helpers/ast.rb
+- lib/loxby/helpers/environment.rb
+- lib/loxby/helpers/errors.rb
+- lib/loxby/helpers/token_type.rb
+- lib/loxby/interpreter.rb
+- lib/loxby/parser.rb
+- lib/loxby/runner.rb
+- lib/loxby/scanner.rb
+- lib/loxby/version.rb
+- lib/loxby/visitors/ast_printer.rb
+- lib/loxby/visitors/base.rb
+- lib/loxby/visitors/rpn_converter.rb
+- loxby.gemspec
+homepage: https://github.com/paul-c-hartman/loxby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/paul-c-hartman/loxby
+  source_code_uri: https://github.com/paul-c-hartman/loxby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: A Lox interpreter written in Ruby
+test_files: []