gemite 0.1.0

data/lib/gemite/interpreter.rb

@@ -0,0 +1,435 @@
+# frozen_string_literal: true
+
+require_relative "ast"
+require_relative "environment"
+require_relative "function"
+require_relative "database"
+require_relative "errors"
+
+module Gemite
+  # テンプレートノード木(TemplateParserの出力)と文AST(Parserの出力)を評価する
+  # ツリーウォーク型インタプリタ。
+  #
+  # 1リクエスト = 1つのInterpreterインスタンム。 render を1回呼ぶと、その中で
+  # ファイル全体を通してグローバル環境(仕様25: グローバル変数はファイル単位)を共有する。
+  class Interpreter
+    include AST
+
+    def initialize(get_params: {}, post_params: {}, base_dir: Dir.pwd)
+      @base_dir = base_dir
+      @global_env = Environment.new
+      @global_env.set_local("get", to_gemite_hash(get_params))
+      @global_env.set_local("post", to_gemite_hash(post_params))
+      @open_databases = []
+    end
+
+    # テンプレートノード列を実行し、出力HTML文字列を返す。
+    # redirect() が呼ばれた場合は Gemite::RedirectSignal が、
+    # 未捕捉のエラーが発生した場合は Gemite::RuntimeError 等がそのまま送出される
+    # (呼び出し元のHTTPサーバ層で捕捉して適切なレスポンスに変換する)。
+    def render(template_nodes)
+      @output = +""
+      exec_tpl_nodes(template_nodes, @global_env)
+      @output
+    ensure
+      close_databases
+    end
+
+    private
+
+    def close_databases
+      @open_databases.each { |db| db.close rescue nil }
+    end
+
+    def to_gemite_hash(h)
+      result = {}
+      (h || {}).each { |k, v| result[k.to_s.to_sym] = v }
+      result
+    end
+
+    # ============ テンプレートノードの実行 ============
+
+    def exec_tpl_nodes(nodes, env)
+      nodes.each { |n| exec_tpl_node(n, env) }
+    end
+
+    def exec_tpl_node(node, env)
+      case node
+      when TplText
+        @output << node.text
+      when TplExpr
+        @output << stringify(eval_expr(node.expr, env))
+      when TplCode
+        exec_statements(node.statements, env)
+      when TplIf
+        exec_tpl_if(node, env)
+      when TplFor
+        exec_tpl_for(node, env)
+      else
+        raise "internal error: unknown template node #{node.class}"
+      end
+    end
+
+    def exec_tpl_if(node, env)
+      branch = node.branches.find { |cond, _body| truthy?(eval_expr(cond, env)) }
+      if branch
+        exec_tpl_nodes(branch[1], env)
+      elsif node.else_body
+        exec_tpl_nodes(node.else_body, env)
+      end
+    end
+
+    def exec_tpl_for(node, env)
+      items = to_enumerable(eval_expr(node.iterable, env))
+      with_loop_var(env, node.var_name, items) do |item|
+        env.set_local(node.var_name, item)
+        exec_tpl_nodes(node.body, env)
+      end
+    end
+
+    # ============ 文の実行 ============
+    # 戻り値は「最後に実行した文の値」(関数の暗黙の戻り値に使う)。
+
+    def exec_statements(stmts, env)
+      result = nil
+      stmts.each { |s| result = exec_statement(s, env) }
+      result
+    end
+
+    def exec_statement(stmt, env)
+      case stmt
+      when Assignment
+        val = eval_expr(stmt.value, env)
+        env.assign(stmt.name, val)
+        val
+      when FunctionDef
+        env.assign(stmt.name, Function.new(stmt.name, stmt.params, stmt.body, env))
+        nil
+      when ReturnStmt
+        raise Gemite::ReturnSignal, eval_expr(stmt.value, env)
+      when ExprStmt
+        eval_expr(stmt.expr, env)
+      when IfStmt
+        exec_if_stmt(stmt, env)
+      when ForStmt
+        exec_for_stmt(stmt, env)
+        nil
+      when BeginCatchStmt
+        exec_begin_catch(stmt, env)
+      else
+        raise "internal error: unknown statement #{stmt.class}"
+      end
+    end
+
+    def exec_if_stmt(stmt, env)
+      branch = stmt.branches.find { |cond, _body| truthy?(eval_expr(cond, env)) }
+      if branch
+        exec_statements(branch[1], env)
+      elsif stmt.else_body
+        exec_statements(stmt.else_body, env)
+      end
+    end
+
+    def exec_for_stmt(stmt, env)
+      items = to_enumerable(eval_expr(stmt.iterable, env))
+      with_loop_var(env, stmt.var_name, items) do |item|
+        env.set_local(stmt.var_name, item)
+        exec_statements(stmt.body, env)
+      end
+    end
+
+    # @forのループ変数だけを退避/復元するヘルパー(仕様25: @for変数はループ内のみ有効)。
+    # ループ変数以外への代入は通常通り現在のスコープに作用する。
+    def with_loop_var(env, var_name, items)
+      had_prior = env.has_local?(var_name)
+      prior_val = env.get_local(var_name)
+      items.each { |item| yield item }
+    ensure
+      if had_prior
+        env.set_local(var_name, prior_val)
+      else
+        env.delete_local(var_name)
+      end
+    end
+
+    def exec_begin_catch(stmt, env)
+      exec_statements(stmt.begin_body, env)
+    rescue Gemite::ReturnSignal, Gemite::RedirectSignal
+      raise
+    rescue StandardError => e
+      env.assign(stmt.err_name, e.message)
+      exec_statements(stmt.catch_body, env)
+    end
+
+    def to_enumerable(val)
+      case val
+      when Array then val
+      when nil then []
+      else
+        raise Gemite::RuntimeError, "@for でループできない値です: #{type_name(val)}"
+      end
+    end
+
+    # ============ 式の評価 ============
+
+    def eval_expr(expr, env)
+      case expr
+      when IntLiteral, FloatLiteral, BoolLiteral, NilLiteral
+        expr.value
+      when StringLiteral
+        eval_string_literal(expr, env)
+      when ArrayLiteral
+        expr.elements.map { |e| eval_expr(e, env) }
+      when HashLiteral
+        h = {}
+        expr.pairs.each { |k, v| h[k] = eval_expr(v, env) }
+        h
+      when Identifier
+        env.get(expr.name)
+      when BinaryOp
+        eval_binary_op(expr, env)
+      when UnaryOp
+        eval_unary_op(expr, env)
+      when LogicalOp
+        eval_logical_op(expr, env)
+      when MemberAccess
+        member_access(eval_expr(expr.receiver, env), expr.name)
+      when IndexAccess
+        index_access(eval_expr(expr.receiver, env), eval_expr(expr.index, env))
+      when CallExpr
+        eval_call(expr, env)
+      when MethodCallExpr
+        eval_method_call(expr, env)
+      else
+        raise "internal error: unknown expression #{expr.class}"
+      end
+    end
+
+    def eval_string_literal(expr, env)
+      expr.parts.map do |(kind, val)|
+        kind == :str ? val : stringify(eval_expr(val, env))
+      end.join
+    end
+
+    def eval_binary_op(expr, env)
+      left = eval_expr(expr.left, env)
+      right = eval_expr(expr.right, env)
+      op = expr.op
+      case op
+      when :+
+        eval_plus(left, right)
+      when :-, :*, :/, :%
+        eval_arith(op, left, right)
+      when :==
+        values_equal?(left, right)
+      when :!=
+        !values_equal?(left, right)
+      when :<, :<=, :>, :>=
+        eval_compare(op, left, right)
+      else
+        raise "internal error: unknown operator #{op}"
+      end
+    end
+
+    def eval_plus(left, right)
+      return left + right if left.is_a?(String) && right.is_a?(String)
+      return left + right if numeric?(left) && numeric?(right)
+
+      raise Gemite::RuntimeError, "'+' は #{type_name(left)} と #{type_name(right)} には使えません"
+    end
+
+    def eval_arith(op, left, right)
+      unless numeric?(left) && numeric?(right)
+        raise Gemite::RuntimeError, "'#{op}' 演算子は数値同士にのみ使えます (#{type_name(left)}, #{type_name(right)})"
+      end
+
+      left.public_send(op, right)
+    rescue ZeroDivisionError
+      raise Gemite::RuntimeError, "ゼロ除算です"
+    end
+
+    def eval_compare(op, left, right)
+      comparable = (numeric?(left) && numeric?(right)) || (left.is_a?(String) && right.is_a?(String))
+      raise Gemite::RuntimeError, "'#{op}' で #{type_name(left)} と #{type_name(right)} を比較できません" unless comparable
+
+      left.public_send(op, right)
+    end
+
+    def eval_unary_op(expr, env)
+      val = eval_expr(expr.operand, env)
+      case expr.op
+      when :-@
+        raise Gemite::RuntimeError, "単項 '-' は数値にのみ使えます (#{type_name(val)})" unless numeric?(val)
+
+        -val
+      when :not
+        !truthy?(val)
+      else
+        raise "internal error: unknown unary operator #{expr.op}"
+      end
+    end
+
+    def eval_logical_op(expr, env)
+      left = eval_expr(expr.left, env)
+      case expr.op
+      when :and
+        truthy?(left) ? eval_expr(expr.right, env) : left
+      when :or
+        truthy?(left) ? left : eval_expr(expr.right, env)
+      else
+        raise "internal error: unknown logical operator #{expr.op}"
+      end
+    end
+
+    def member_access(receiver, name)
+      return receiver[name.to_sym] if receiver.is_a?(Hash)
+
+      nil
+    end
+
+    def index_access(receiver, index)
+      case receiver
+      when Array
+        index.is_a?(Integer) ? receiver[index] : nil
+      when Hash
+        key = index.is_a?(String) ? index.to_sym : index
+        receiver[key]
+      else
+        nil
+      end
+    end
+
+    BUILTIN_FUNCTIONS = %w[sqlite redirect puts].freeze
+
+    def eval_call(expr, env)
+      args = expr.args.map { |a| eval_expr(a, env) }
+      if BUILTIN_FUNCTIONS.include?(expr.callee_name)
+        call_builtin(expr.callee_name, args)
+      else
+        fn = env.get(expr.callee_name)
+        raise Gemite::RuntimeError, "未定義の関数です: #{expr.callee_name}" unless fn.is_a?(Gemite::Function)
+
+        call_function(fn, args)
+      end
+    end
+
+    def call_builtin(name, args)
+      case name
+      when "sqlite"
+        path = args[0]
+        raise Gemite::RuntimeError, "sqlite() にはファイルパス(文字列)を渡してください" unless path.is_a?(String)
+
+        db = Gemite::Database.new(resolve_db_path(path))
+        @open_databases << db
+        db
+      when "redirect"
+        raise Gemite::RedirectSignal, args[0].to_s
+      when "puts"
+        $stdout.puts(args.map { |a| stringify(a) }.join(" "))
+        $stdout.flush
+        nil
+      end
+    end
+
+    def resolve_db_path(path)
+      return path if path.start_with?("/")
+
+      File.join(@base_dir, path)
+    end
+
+    def call_function(fn, args)
+      call_env = Environment.new(parent: fn.closure_env, boundary: true)
+      fn.params.each_with_index { |param, i| call_env.set_local(param, args[i]) }
+      exec_statements(fn.body, call_env)
+    rescue Gemite::ReturnSignal => e
+      e.value
+    end
+
+    def eval_method_call(expr, env)
+      receiver = eval_expr(expr.receiver, env)
+      args = expr.args.map { |a| eval_expr(a, env) }
+      case receiver
+      when Gemite::Database
+        call_database_method(receiver, expr.method_name, args)
+      else
+        raise Gemite::RuntimeError, "#{type_name(receiver)} に対して '#{expr.method_name}' は呼び出せません"
+      end
+    end
+
+    def call_database_method(db, name, args)
+      case name
+      when "select"
+        db.select(args[0], args[1] || {})
+      when "insert"
+        db.insert(args[0], args[1] || {})
+      when "update"
+        db.update(args[0], args[1] || {}, args[2] || {})
+      when "delete"
+        db.delete(args[0], args[1] || {})
+      when "exec"
+        db.exec(args[0])
+      else
+        raise Gemite::RuntimeError, "データベースに '#{name}' メソッドはありません"
+      end
+    end
+
+    # ============ 値のユーティリティ ============
+
+    def numeric?(v)
+      v.is_a?(Integer) || v.is_a?(Float)
+    end
+
+    def values_equal?(a, b)
+      a == b
+    rescue StandardError
+      false
+    end
+
+    # 仕様24: false / nil / 0 / "" / [] / {} が偽、それ以外は真。
+    def truthy?(val)
+      return false if val.nil? || val == false
+      return false if val.is_a?(Numeric) && val.zero?
+      return false if val.is_a?(String) && val.empty?
+      return false if val.is_a?(Array) && val.empty?
+      return false if val.is_a?(Hash) && val.empty?
+
+      true
+    end
+
+    def type_name(v)
+      case v
+      when nil then "nil"
+      when true, false then "真偽値"
+      when Integer, Float then "数値"
+      when String then "文字列"
+      when Array then "配列"
+      when Hash then "連想配列"
+      when Gemite::Function then "関数"
+      when Gemite::Database then "データベース"
+      else v.class.name
+      end
+    end
+
+    def stringify(val)
+      case val
+      when nil then ""
+      when String then val
+      when Integer, Float then val.to_s
+      when true then "true"
+      when false then "false"
+      when Array
+        "[" + val.map { |v| stringify_debug(v) }.join(", ") + "]"
+      when Hash
+        "{" + val.map { |k, v| "#{k}: #{stringify_debug(v)}" }.join(", ") + "}"
+      when Gemite::Function, Gemite::Database
+        val.to_s
+      else
+        val.to_s
+      end
+    end
+
+    def stringify_debug(val)
+      val.is_a?(String) ? val.inspect : stringify(val)
+    end
+  end
+end

data/lib/gemite/lexer.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require_relative "token"
+require_relative "errors"
+
+module Gemite
+  # Gemiteの「コード」部分(<?gemite ... ?> の中身や、{ ... } 補間の中身)を
+  # トークン列に変換する。HTMLの生テキストは扱わない(それは TemplateParser の仕事)。
+  class Lexer
+    KEYWORDS = {
+      "def" => :DEF,
+      "end" => :END,
+      "return" => :RETURN,
+      "true" => :TRUE,
+      "false" => :FALSE,
+      "nil" => :NIL,
+      "and" => :AND,
+      "or" => :OR,
+      "not" => :NOT,
+      "begin" => :BEGIN,
+      "catch" => :CATCH,
+      "in" => :IN
+    }.freeze
+
+    # @if / @for などの "@"付きディレクティブ。コードブロック内でも仕様通り
+    # @endif / @end を使う(defやbeginの素のendとは別体系)。
+    AT_KEYWORDS = {
+      "if" => :AT_IF,
+      "elseif" => :AT_ELSEIF,
+      "else" => :AT_ELSE,
+      "endif" => :AT_ENDIF,
+      "for" => :AT_FOR,
+      "end" => :AT_END
+    }.freeze
+
+    OPERATORS = [
+      ["==", :EQ], ["!=", :NEQ], ["<=", :LTE], [">=", :GTE],
+      ["<", :LT], [">", :GT], ["=", :ASSIGN],
+      ["+", :PLUS], ["-", :MINUS], ["*", :STAR], ["/", :SLASH], ["%", :PERCENT],
+      ["(", :LPAREN], [")", :RPAREN], ["[", :LBRACKET], ["]", :RBRACKET],
+      ["{", :LBRACE], ["}", :RBRACE], [",", :COMMA], [":", :COLON], [".", :DOT]
+    ].freeze
+
+    def initialize(source, line: 1)
+      @src = source
+      @pos = 0
+      @len = source.length
+      @line = line
+    end
+
+    # 直前のトークンがこれらのいずれかである場合、続く改行は「行継続」とみなし
+    # NEWLINEトークンを生成しない。これにより
+    #   comments =
+    #       db.select(...)
+    # のように "=" や演算子・開き括弧・カンマの直後で改行して値を次行に続える
+    # 書き方(仕様書28の例で実際に使われている)を、文終端の改行と区別できる。
+    CONTINUATION_TOKENS = %i[
+      ASSIGN PLUS MINUS STAR SLASH PERCENT
+      EQ NEQ LT LTE GT GTE AND OR NOT
+      COMMA COLON DOT LPAREN LBRACKET LBRACE
+    ].freeze
+
+    def tokenize
+      tokens = []
+      loop do
+        tok = next_token
+        if tok.type == :NEWLINE && CONTINUATION_TOKENS.include?(tokens.last&.type)
+          next
+        end
+        tokens << tok
+        break if tok.type == :EOF
+      end
+      tokens
+    end
+
+    private
+
+    def peek_char(offset = 0)
+      idx = @pos + offset
+      idx < @len ? @src[idx] : nil
+    end
+
+    def advance_char
+      ch = @src[@pos]
+      @pos += 1
+      @line += 1 if ch == "\n"
+      ch
+    end
+
+    def eof?
+      @pos >= @len
+    end
+
+    def next_token
+      skip_insignificant
+      start_line = @line
+      return Token.new(:EOF, nil, start_line) if eof?
+
+      ch = peek_char
+      return lex_newline(start_line) if ch == "\n"
+      return lex_number(start_line) if digit?(ch)
+      return lex_string(start_line) if ch == '"'
+      return lex_at_keyword(start_line) if ch == "@"
+      return lex_ident(start_line) if ident_start?(ch)
+
+      lex_operator(start_line)
+    end
+
+    def digit?(ch)
+      !ch.nil? && ch >= "0" && ch <= "9"
+    end
+
+    def ident_start?(ch)
+      !ch.nil? && (ch =~ /[A-Za-z_]/)
+    end
+
+    def ident_char?(ch)
+      !ch.nil? && (ch =~ /[A-Za-z0-9_]/)
+    end
+
+    # 改行以外の空白・コメント(# から行末まで)を読み飛ばす。
+    # 改行はステートメント区切りとして意味を持つのでここでは消費しない。
+    def skip_insignificant
+      loop do
+        ch = peek_char
+        if ch == " " || ch == "\t" || ch == "\r"
+          advance_char
+        elsif ch == "#"
+          advance_char while peek_char && peek_char != "\n"
+        else
+          break
+        end
+      end
+    end
+
+    # 連続する改行(間の空白/コメント含む)をまとめて1つのNEWLINEトークンにする
+    def lex_newline(line)
+      loop do
+        advance_char if peek_char == "\n"
+        skip_insignificant
+        break unless peek_char == "\n"
+      end
+      Token.new(:NEWLINE, nil, line)
+    end
+
+    def lex_number(line)
+      start = @pos
+      advance_char while digit?(peek_char)
+      if peek_char == "." && digit?(peek_char(1))
+        advance_char
+        advance_char while digit?(peek_char)
+        return Token.new(:FLOAT, @src[start...@pos].to_f, line)
+      end
+      Token.new(:INT, @src[start...@pos].to_i, line)
+    end
+
+    def lex_ident(line)
+      start = @pos
+      advance_char while ident_char?(peek_char)
+      word = @src[start...@pos]
+      type = KEYWORDS[word]
+      type ? Token.new(type, word, line) : Token.new(:IDENT, word, line)
+    end
+
+    def lex_at_keyword(line)
+      advance_char # '@'
+      start = @pos
+      advance_char while ident_char?(peek_char)
+      word = @src[start...@pos]
+      type = AT_KEYWORDS[word]
+      raise Gemite::SyntaxError.new("不明なディレクティブ '@#{word}'", line: line) unless type
+
+      Token.new(type, "@#{word}", line)
+    end
+
+    # 文字列リテラル。#{ ... } による式補間を [:str, text] / [:expr, source] の
+    # 配列として保持する(実際の式へのパースは Parser 側で行う)。
+    def lex_string(line)
+      advance_char # 開き "
+      parts = []
+      buf = +""
+      loop do
+        ch = peek_char
+        raise Gemite::SyntaxError.new("文字列リテラルが閉じられていません", line: line) if ch.nil?
+
+        case ch
+        when '"'
+          advance_char
+          break
+        when "\\"
+          advance_char
+          buf << unescape(peek_char)
+          advance_char
+        when "#"
+          if peek_char(1) == "{"
+            parts << [:str, buf] unless buf.empty?
+            buf = +""
+            advance_char # '#'
+            advance_char # '{'
+            parts << [:expr, scan_interpolation_source(line)]
+          else
+            buf << ch
+            advance_char
+          end
+        else
+          buf << ch
+          advance_char
+        end
+      end
+      parts << [:str, buf] unless buf.empty?
+      parts << [:str, ""] if parts.empty?
+      Token.new(:STRING, parts, line)
+    end
+
+    def unescape(ch)
+      case ch
+      when "n" then "\n"
+      when "t" then "\t"
+      when "r" then "\r"
+      when '"' then '"'
+      when "\\" then "\\"
+      when "#" then "#"
+      when nil then ""
+      else ch
+      end
+    end
+
+    # #{ の直後から対応する } までの生ソースを取り出す。
+    # ネストした {}(ハッシュリテラル等)や、内部の文字列リテラルにも対応する。
+    def scan_interpolation_source(line)
+      depth = 1
+      in_str = false
+      buf = +""
+      loop do
+        ch = peek_char
+        raise Gemite::SyntaxError.new("補間式 #{'#'}{...} が閉じられていません", line: line) if ch.nil?
+
+        if in_str
+          buf << ch
+          if ch == "\\"
+            advance_char
+            buf << peek_char.to_s
+            advance_char
+          elsif ch == '"'
+            in_str = false
+            advance_char
+          else
+            advance_char
+          end
+          next
+        end
+
+        case ch
+        when '"'
+          in_str = true
+          buf << ch
+          advance_char
+        when "{"
+          depth += 1
+          buf << ch
+          advance_char
+        when "}"
+          depth -= 1
+          if depth.zero?
+            advance_char
+            break
+          else
+            buf << ch
+            advance_char
+          end
+        else
+          buf << ch
+          advance_char
+        end
+      end
+      buf
+    end
+
+    def lex_operator(line)
+      OPERATORS.each do |(text, type)|
+        if @src[@pos, text.length] == text
+          text.length.times { advance_char }
+          return Token.new(type, text, line)
+        end
+      end
+      raise Gemite::SyntaxError.new("不明な文字 '#{peek_char}'", line: line)
+    end
+  end
+end