gemite 0.1.0

data/lib/gemite/parser.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require_relative "token"
+require_relative "ast"
+require_relative "errors"
+require_relative "lexer"
+
+module Gemite
+  # <?gemite ... ?> の中身や、式の断片(補間・@ifの条件式など)をASTへ変換する。
+  # 再帰下降パーサー。
+  class Parser
+    include AST
+
+    # ソース文字列全体を「文の並び」としてパースする(<?gemite ?>ブロックの中身用)
+    def self.parse_statements_from_source(source, line: 1)
+      tokens = Lexer.new(source, line: line).tokenize
+      new(tokens).parse_statements_until(nil)
+    end
+
+    # ソース文字列を単一の式としてパースする({expr}補間や@if条件式用)
+    def self.parse_expression_from_source(source, line: 1)
+      tokens = Lexer.new(source, line: line).tokenize
+      parser = new(tokens)
+      parser.send(:skip_newlines)
+      expr = parser.send(:parse_expression)
+      parser.send(:skip_newlines)
+      unless parser.send(:check, :EOF)
+        tok = parser.send(:current)
+        raise Gemite::SyntaxError.new("式の後に余分なトークンがあります (#{tok.type})", line: tok.line)
+      end
+      expr
+    end
+
+    # "var in iterable" 形式(@forの節)をパースする
+    def self.parse_for_clause_from_source(source, line: 1)
+      tokens = Lexer.new(source, line: line).tokenize
+      new(tokens).parse_for_clause
+    end
+
+    def initialize(tokens)
+      @tokens = tokens
+      @pos = 0
+    end
+
+    def parse_for_clause
+      name_tok = expect(:IDENT)
+      expect(:IN)
+      iterable = parse_expression
+      [name_tok.value, iterable]
+    end
+
+    # stop_types: nilならEOFまで。配列ならそのトークン型に出会うまで(消費はしない)。
+    def parse_statements_until(stop_types)
+      stmts = []
+      skip_newlines
+      loop do
+        break if check(:EOF)
+        break if stop_types && stop_types.include?(current.type)
+
+        stmts << parse_statement
+        skip_newlines
+      end
+      stmts
+    end
+
+    private
+
+    def current
+      @tokens[@pos]
+    end
+
+    def peek(offset = 1)
+      idx = @pos + offset
+      idx < @tokens.length ? @tokens[idx] : @tokens.last
+    end
+
+    def advance
+      tok = current
+      @pos += 1 unless tok.type == :EOF
+      tok
+    end
+
+    def check(type)
+      current.type == type
+    end
+
+    def accept(type)
+      check(type) ? advance : nil
+    end
+
+    def expect(type)
+      unless check(type)
+        raise Gemite::SyntaxError.new(
+          "#{type} を期待しましたが #{current.type}(#{current.value.inspect}) でした",
+          line: current.line
+        )
+      end
+      advance
+    end
+
+    def skip_newlines
+      advance while check(:NEWLINE)
+    end
+
+    # ============ 文 ============
+
+    def parse_statement
+      case current.type
+      when :DEF then parse_function_def
+      when :RETURN then parse_return
+      when :AT_IF then parse_if_stmt
+      when :AT_FOR then parse_for_stmt
+      when :BEGIN then parse_begin_catch
+      when :IDENT
+        peek.type == :ASSIGN ? parse_assignment : ExprStmt.new(parse_expression)
+      else
+        ExprStmt.new(parse_expression)
+      end
+    end
+
+    def parse_assignment
+      name_tok = expect(:IDENT)
+      expect(:ASSIGN)
+      skip_newlines
+      value = parse_expression
+      Assignment.new(name_tok.value, value)
+    end
+
+    def parse_function_def
+      expect(:DEF)
+      name_tok = expect(:IDENT)
+      expect(:LPAREN)
+      params = []
+      skip_newlines
+      unless check(:RPAREN)
+        loop do
+          skip_newlines
+          params << expect(:IDENT).value
+          skip_newlines
+          break unless accept(:COMMA)
+        end
+      end
+      skip_newlines
+      expect(:RPAREN)
+      body = parse_statements_until(%i[END])
+      expect(:END)
+      FunctionDef.new(name_tok.value, params, body)
+    end
+
+    RETURN_STOPPERS = %i[NEWLINE EOF END AT_ENDIF AT_ELSEIF AT_ELSE AT_END CATCH].freeze
+
+    def parse_return
+      expect(:RETURN)
+      if RETURN_STOPPERS.include?(current.type)
+        ReturnStmt.new(NilLiteral.new(nil))
+      else
+        ReturnStmt.new(parse_expression)
+      end
+    end
+
+    def parse_if_stmt
+      branches = []
+      expect(:AT_IF)
+      cond = parse_expression
+      body = parse_statements_until(%i[AT_ELSEIF AT_ELSE AT_ENDIF])
+      branches << [cond, body]
+
+      while check(:AT_ELSEIF)
+        advance
+        c = parse_expression
+        b = parse_statements_until(%i[AT_ELSEIF AT_ELSE AT_ENDIF])
+        branches << [c, b]
+      end
+
+      else_body = nil
+      if accept(:AT_ELSE)
+        else_body = parse_statements_until(%i[AT_ENDIF])
+      end
+      expect(:AT_ENDIF)
+      IfStmt.new(branches, else_body)
+    end
+
+    def parse_for_stmt
+      expect(:AT_FOR)
+      name_tok = expect(:IDENT)
+      expect(:IN)
+      iterable = parse_expression
+      body = parse_statements_until(%i[AT_END])
+      expect(:AT_END)
+      ForStmt.new(name_tok.value, iterable, body)
+    end
+
+    def parse_begin_catch
+      expect(:BEGIN)
+      begin_body = parse_statements_until(%i[CATCH])
+      expect(:CATCH)
+      err_tok = expect(:IDENT)
+      catch_body = parse_statements_until(%i[END])
+      expect(:END)
+      BeginCatchStmt.new(begin_body, err_tok.value, catch_body)
+    end
+
+    # ============ 式(優先順位の低い順) ============
+
+    def parse_expression
+      parse_or
+    end
+
+    def parse_or
+      left = parse_and
+      while check(:OR)
+        advance
+        left = LogicalOp.new(:or, left, parse_and)
+      end
+      left
+    end
+
+    def parse_and
+      left = parse_equality
+      while check(:AND)
+        advance
+        left = LogicalOp.new(:and, left, parse_equality)
+      end
+      left
+    end
+
+    EQUALITY_OPS = { EQ: :==, NEQ: :!= }.freeze
+
+    def parse_equality
+      left = parse_comparison
+      while EQUALITY_OPS.key?(current.type)
+        op = EQUALITY_OPS[advance.type]
+        left = BinaryOp.new(op, left, parse_comparison)
+      end
+      left
+    end
+
+    COMPARISON_OPS = { LT: :<, LTE: :<=, GT: :>, GTE: :>= }.freeze
+
+    def parse_comparison
+      left = parse_additive
+      while COMPARISON_OPS.key?(current.type)
+        op = COMPARISON_OPS[advance.type]
+        left = BinaryOp.new(op, left, parse_additive)
+      end
+      left
+    end
+
+    ADDITIVE_OPS = { PLUS: :+, MINUS: :- }.freeze
+
+    def parse_additive
+      left = parse_multiplicative
+      while ADDITIVE_OPS.key?(current.type)
+        op = ADDITIVE_OPS[advance.type]
+        left = BinaryOp.new(op, left, parse_multiplicative)
+      end
+      left
+    end
+
+    MULT_OPS = { STAR: :*, SLASH: :/, PERCENT: :% }.freeze
+
+    def parse_multiplicative
+      left = parse_unary
+      while MULT_OPS.key?(current.type)
+        op = MULT_OPS[advance.type]
+        left = BinaryOp.new(op, left, parse_unary)
+      end
+      left
+    end
+
+    def parse_unary
+      if check(:MINUS)
+        advance
+        return UnaryOp.new(:-@, parse_unary)
+      end
+      if check(:NOT)
+        advance
+        return UnaryOp.new(:not, parse_unary)
+      end
+      parse_postfix
+    end
+
+    def parse_postfix
+      expr = parse_primary
+      loop do
+        case current.type
+        when :DOT
+          advance
+          name_tok = expect(:IDENT)
+          if check(:LPAREN)
+            advance
+            args = parse_call_args
+            expect(:RPAREN)
+            expr = MethodCallExpr.new(expr, name_tok.value, args)
+          else
+            expr = MemberAccess.new(expr, name_tok.value)
+          end
+        when :LBRACKET
+          advance
+          skip_newlines
+          idx = parse_expression
+          skip_newlines
+          expect(:RBRACKET)
+          expr = IndexAccess.new(expr, idx)
+        else
+          break
+        end
+      end
+      expr
+    end
+
+    def parse_primary
+      tok = current
+      case tok.type
+      when :INT
+        advance
+        IntLiteral.new(tok.value)
+      when :FLOAT
+        advance
+        FloatLiteral.new(tok.value)
+      when :STRING
+        advance
+        StringLiteral.new(build_string_parts(tok.value, tok.line))
+      when :TRUE
+        advance
+        BoolLiteral.new(true)
+      when :FALSE
+        advance
+        BoolLiteral.new(false)
+      when :NIL
+        advance
+        NilLiteral.new(nil)
+      when :IDENT
+        advance
+        if check(:LPAREN)
+          advance
+          args = parse_call_args
+          expect(:RPAREN)
+          CallExpr.new(tok.value, args)
+        else
+          Identifier.new(tok.value)
+        end
+      when :LPAREN
+        advance
+        skip_newlines
+        expr = parse_expression
+        skip_newlines
+        expect(:RPAREN)
+        expr
+      when :LBRACKET
+        parse_array_literal
+      when :LBRACE
+        parse_hash_literal
+      else
+        raise Gemite::SyntaxError.new("式が必要です ('#{tok.type}' は使用できません)", line: tok.line)
+      end
+    end
+
+    def parse_array_literal
+      expect(:LBRACKET)
+      elements = []
+      skip_newlines
+      unless check(:RBRACKET)
+        loop do
+          skip_newlines
+          elements << parse_expression
+          skip_newlines
+          break unless accept(:COMMA)
+        end
+      end
+      skip_newlines
+      expect(:RBRACKET)
+      ArrayLiteral.new(elements)
+    end
+
+    def parse_hash_literal
+      expect(:LBRACE)
+      pairs = []
+      skip_newlines
+      unless check(:RBRACE)
+        loop do
+          skip_newlines
+          key_tok = expect(:IDENT)
+          expect(:COLON)
+          skip_newlines
+          value = parse_expression
+          pairs << [key_tok.value.to_sym, value]
+          skip_newlines
+          break unless accept(:COMMA)
+        end
+      end
+      skip_newlines
+      expect(:RBRACE)
+      HashLiteral.new(pairs)
+    end
+
+    # 呼び出し引数。位置引数と "key: value" 形式(末尾に暗黙のハッシュとしてまとめる)の
+    # 両方に対応する。 db.select("users", where: {age: 15}) のような呼び出しのため。
+    def parse_call_args
+      positional = []
+      keyword_pairs = []
+      skip_newlines
+      unless check(:RPAREN)
+        loop do
+          skip_newlines
+          if check(:IDENT) && peek.type == :COLON
+            key_tok = advance
+            advance # COLON
+            skip_newlines
+            keyword_pairs << [key_tok.value.to_sym, parse_expression]
+          else
+            positional << parse_expression
+          end
+          skip_newlines
+          break unless accept(:COMMA)
+        end
+      end
+      skip_newlines
+      positional << HashLiteral.new(keyword_pairs) unless keyword_pairs.empty?
+      positional
+    end
+
+    def build_string_parts(raw_parts, line)
+      raw_parts.map do |(kind, val)|
+        if kind == :str
+          [:str, val]
+        else
+          [:expr, Parser.parse_expression_from_source(val, line: line)]
+        end
+      end
+    end
+  end
+end

data/lib/gemite/request.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Gemite
+  # 生のHTTPリクエストをパースした結果を保持する。
+  class Request
+    attr_reader :method, :path, :query_params, :headers, :body, :form_params
+
+    def initialize(method:, path:, query_params:, headers:, body:)
+      @method = method
+      @path = path
+      @query_params = query_params
+      @headers = headers
+      @body = body
+      @form_params = parse_form_body
+    end
+
+    # application/x-www-form-urlencoded のボディをパースする。
+    # multipart/form-data(ファイルアップロード)はv0.1では対象外。
+    def parse_form_body
+      return {} if body.nil? || body.empty?
+
+      content_type = headers["content-type"] || ""
+      return {} unless content_type.include?("application/x-www-form-urlencoded") || content_type.empty?
+
+      parse_www_form(body)
+    end
+
+    def self.parse_www_form(str)
+      result = {}
+      str.split("&").each do |pair|
+        next if pair.empty?
+
+        k, v = pair.split("=", 2)
+        result[uri_decode(k)] = uri_decode(v || "")
+      end
+      result
+    end
+
+    def self.uri_decode(str)
+      str.to_s.tr("+", " ").gsub(/%([0-9A-Fa-f]{2})/) { [Regexp.last_match(1)].pack("H2").force_encoding("BINARY") }
+         .force_encoding("BINARY").force_encoding("UTF-8")
+    end
+
+    def parse_www_form(str)
+      self.class.parse_www_form(str)
+    end
+    private :parse_www_form
+  end
+end

data/lib/gemite/router.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Gemite
+  # リクエストパスから .gmt ファイル、または public/ 配下の静的ファイルを解決する。
+  #
+  # 仕様4: ファイルはURLへ直接マッピングされる(index.gmt -> /, login.gmt -> /login 等)。
+  # ディレクトリ構成は自由なので、サーバ起動時のカレントディレクトリを
+  # プロジェクトルートとして扱い、リクエストパスをそのまま相対パスとして解決する。
+  class Router
+    EXTENSION = ".gmt"
+    STATIC_DIR = "public"
+
+    MIME_TYPES = {
+      ".html" => "text/html; charset=utf-8",
+      ".htm" => "text/html; charset=utf-8",
+      ".css" => "text/css; charset=utf-8",
+      ".js" => "text/javascript; charset=utf-8",
+      ".mjs" => "text/javascript; charset=utf-8",
+      ".json" => "application/json; charset=utf-8",
+      ".png" => "image/png",
+      ".jpg" => "image/jpeg",
+      ".jpeg" => "image/jpeg",
+      ".gif" => "image/gif",
+      ".svg" => "image/svg+xml",
+      ".ico" => "image/x-icon",
+      ".webp" => "image/webp",
+      ".woff" => "font/woff",
+      ".woff2" => "font/woff2",
+      ".txt" => "text/plain; charset=utf-8",
+      ".xml" => "application/xml; charset=utf-8",
+      ".pdf" => "application/pdf"
+    }.freeze
+
+    def initialize(root)
+      @root = File.expand_path(root)
+    end
+
+    Result = Struct.new(:type, :path) # type: :gemite | :static | :not_found
+
+    def resolve(request_path)
+      clean = normalize(request_path)
+      return Result.new(:not_found, nil) unless clean
+
+      gemite_path = find_gemite_file(clean)
+      return Result.new(:gemite, gemite_path) if gemite_path
+
+      static_path = find_static_file(clean)
+      return Result.new(:static, static_path) if static_path
+
+      Result.new(:not_found, nil)
+    end
+
+    def mime_type_for(path)
+      MIME_TYPES[File.extname(path).downcase] || "application/octet-stream"
+    end
+
+    private
+
+    # ".." 等によるルート外アクセスを防ぐための正規化。
+    def normalize(request_path)
+      path = request_path.split("?").first.to_s
+      path = "/" if path.empty?
+      segments = path.split("/").reject { |s| s.empty? || s == "." }
+      return nil if segments.include?("..")
+
+      "/" + segments.join("/")
+    end
+
+    def find_gemite_file(clean_path)
+      rel = clean_path == "/" ? "index" : clean_path.sub(%r{\A/}, "")
+      direct = safe_join("#{rel}#{EXTENSION}")
+      return direct if direct && File.file?(direct)
+
+      index = safe_join(File.join(rel, "index#{EXTENSION}"))
+      return index if index && File.file?(index)
+
+      nil
+    end
+
+    def find_static_file(clean_path)
+      rel = clean_path.sub(%r{\A/}, "")
+      return nil if rel.empty?
+
+      candidate = safe_join(File.join(STATIC_DIR, rel))
+      return candidate if candidate && File.file?(candidate)
+
+      nil
+    end
+
+    # @rootの外に出ないことを保証した上でパスを結合する。範囲外なら nil を返す。
+    def safe_join(rel)
+      full = File.expand_path(File.join(@root, rel))
+      return nil unless full == @root || full.start_with?(@root + File::SEPARATOR)
+
+      full
+    end
+  end
+end