gemite 0.1.0

data/lib/gemite/cli.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "version"
+require_relative "http_server"
+
+module Gemite
+  # `gemite` コマンドの実装。仕様3のコマンド体系:
+  #   gemite            開発サーバ起動 (localhost:8000)
+  #   gemite s          開発サーバ起動
+  #   gemite s 3000     ポート指定
+  #   gemite start      "gemite s" の正式名称
+  #   gemite start 3000 ポート指定
+  #   gemite version    バージョン表示
+  #   gemite help       ヘルプ表示
+  module CLI
+    DEFAULT_PORT = 8000
+
+    def self.run(argv)
+      cmd = argv[0]
+
+      case cmd
+      when nil, "s", "start"
+        start_server(argv[1])
+      when "version", "--version", "-v"
+        print_version
+      when "help", "--help", "-h"
+        print_help
+      else
+        warn "不明なコマンドです: #{cmd}"
+        warn ""
+        print_help
+        exit(1)
+      end
+    end
+
+    def self.start_server(port_arg)
+      port = parse_port(port_arg)
+      Gemite::HttpServer.new(root: Dir.pwd, port: port).start
+    end
+    private_class_method :start_server
+
+    def self.parse_port(arg)
+      return DEFAULT_PORT if arg.nil? || arg.strip.empty?
+
+      unless arg =~ /\A\d+\z/
+        warn "ポート番号が不正です: #{arg}"
+        exit(1)
+      end
+      arg.to_i
+    end
+    private_class_method :parse_port
+
+    def self.print_version
+      puts "Gemite #{Gemite::VERSION}"
+    end
+    private_class_method :print_version
+
+    def self.print_help
+      puts <<~HELP
+        Gemite #{Gemite::VERSION} - HTMLファーストな小規模Webアプリ言語
+
+        使い方:
+          gemite              開発サーバを起動する (http://localhost:8000)
+          gemite s            開発サーバを起動する
+          gemite s PORT       ポートを指定して開発サーバを起動する
+          gemite start        "gemite s" の正式名称
+          gemite start PORT   ポートを指定して開発サーバを起動する
+          gemite version      バージョンを表示する
+          gemite help         このヘルプを表示する
+
+        現在のディレクトリを起点に .gmt ファイルをそのままURLへマッピングします。
+          index.gmt              -> /
+          login.gmt               -> /login
+          users/profile.gmt       -> /users/profile
+
+        静的ファイルは public/ 以下に置いてください(例: public/css/style.css -> /css/style.css)。
+      HELP
+    end
+    private_class_method :print_help
+  end
+end

data/lib/gemite/database.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "sqlite3_ffi"
+require_relative "errors"
+
+module Gemite
+  # Gemiteコード上の `db = sqlite("app.db")` で得られるオブジェクトの実体。
+  # 仕様18〜22の select/insert/update/delete/exec をSQLに組み立てて実行する。
+  class Database
+    IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+    def initialize(path)
+      @handle = SQLite3FFI::Handle.new(path)
+    end
+
+    # 生SQLを実行する(CREATE TABLE等、戻り値を使わない用途)。
+    def exec(sql)
+      @handle.exec(sql.to_s)
+      nil
+    end
+
+    # 全件、または where: {col: val, ...} 条件でSELECTする。
+    def select(table, opts = {})
+      table_sql = quote_identifier(table)
+      where_hash = opts.is_a?(Hash) ? (opts[:where] || opts["where"]) : nil
+      clause, params = build_where(where_hash)
+      sql = "SELECT * FROM #{table_sql}#{clause}"
+      @handle.query(sql, params)
+    end
+
+    # {col: val, ...} をINSERTする。
+    def insert(table, values)
+      values = values || {}
+      table_sql = quote_identifier(table)
+      cols = values.keys
+      return nil if cols.empty?
+
+      col_sql = cols.map { |c| quote_identifier(c) }.join(", ")
+      placeholders = (["?"] * cols.length).join(", ")
+      sql = "INSERT INTO #{table_sql} (#{col_sql}) VALUES (#{placeholders})"
+      result = @handle.execute(sql, cols.map { |c| values[c] })
+      result[:rowid]
+    end
+
+    # {col: val, ...} でUPDATEする。where: {col: val, ...} で対象を絞る。
+    def update(table, values, opts = {})
+      values = values || {}
+      table_sql = quote_identifier(table)
+      cols = values.keys
+      return 0 if cols.empty?
+
+      set_sql = cols.map { |c| "#{quote_identifier(c)} = ?" }.join(", ")
+      set_params = cols.map { |c| values[c] }
+
+      where_hash = opts.is_a?(Hash) ? (opts[:where] || opts["where"]) : nil
+      clause, where_params = build_where(where_hash)
+
+      sql = "UPDATE #{table_sql} SET #{set_sql}#{clause}"
+      result = @handle.execute(sql, set_params + where_params)
+      result[:changes]
+    end
+
+    # where: {col: val, ...} に一致する行をDELETEする。
+    def delete(table, opts = {})
+      table_sql = quote_identifier(table)
+      where_hash = opts.is_a?(Hash) ? (opts[:where] || opts["where"]) : nil
+      clause, params = build_where(where_hash)
+      sql = "DELETE FROM #{table_sql}#{clause}"
+      result = @handle.execute(sql, params)
+      result[:changes]
+    end
+
+    def close
+      @handle.close
+    end
+
+    private
+
+    # where: {a: 1, b: "x"} -> [" WHERE a = ? AND b = ?", [1, "x"]]
+    def build_where(where_hash)
+      return ["", []] if where_hash.nil? || where_hash.empty?
+
+      conds = []
+      params = []
+      where_hash.each do |col, val|
+        conds << "#{quote_identifier(col)} = ?"
+        params << val
+      end
+      [" WHERE #{conds.join(' AND ')}", params]
+    end
+
+    def quote_identifier(name)
+      str = name.to_s
+      unless IDENTIFIER.match?(str)
+        raise Gemite::RuntimeError, "不正なテーブル名/カラム名です: #{str.inspect}"
+      end
+
+      "\"#{str}\""
+    end
+  end
+end

data/lib/gemite/environment.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Gemite
+  # 変数を保持するスコープ。
+  #
+  # スコープ規則(仕様25):
+  #   - グローバル変数はファイル単位 -> ルートのEnvironment(boundary:false, parent:nil)を
+  #     ファイル実行全体(<?gemite ?>ブロックをまたいでも)で共有する。
+  #   - 関数内変数はローカル -> 関数呼び出し時に boundary: true の新しい環境を作る。
+  #     assign(代入)はこの境界を越えて外側を書き換えない。ただし読み取り(get)は
+  #     外側(クロージャ)を辿れる。
+  #   - @forのループ変数はループ内のみ有効 -> こちらはEnvironmentを増やさず、
+  #     Interpreter側でループ変数名だけ退避/削除することで実現する(他の代入は
+  #     通常通り現在のスコープに作用する)。
+  class Environment
+    attr_reader :parent
+
+    def initialize(parent: nil, boundary: false)
+      @vars = {}
+      @parent = parent
+      @boundary = boundary
+    end
+
+    def boundary?
+      @boundary
+    end
+
+    def has_local?(name)
+      @vars.key?(name)
+    end
+
+    def get_local(name)
+      @vars[name]
+    end
+
+    def set_local(name, value)
+      @vars[name] = value
+    end
+
+    def delete_local(name)
+      @vars.delete(name)
+    end
+
+    # 一般的な代入。既存の束縛が(関数境界を越えない範囲で)見つかればそこを更新し、
+    # 見つからなければ現在のスコープに新規作成する。
+    def assign(name, value)
+      env = self
+      loop do
+        if env.has_local?(name)
+          env.set_local(name, value)
+          return value
+        end
+        break if env.boundary? || env.parent.nil?
+
+        env = env.parent
+      end
+      set_local(name, value)
+      value
+    end
+
+    # 変数の読み取り。関数境界を越えて外側(クロージャ)を辿る。
+    # 未定義の変数は nil (寛容な設計。GET/POST同様に「存在しなければnil」に統一)。
+    def get(name)
+      env = self
+      while env
+        return env.get_local(name) if env.has_local?(name)
+
+        env = env.parent
+      end
+      nil
+    end
+  end
+end

data/lib/gemite/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gemite
+  # 字句解析・構文解析エラー
+  class SyntaxError < StandardError
+    attr_reader :line
+
+    def initialize(message, line: nil)
+      @line = line
+      super(line ? "#{message} (#{line}行目)" : message)
+    end
+  end
+
+  # Gemiteコード実行中のエラー。begin/catch の err にはこの例外オブジェクトが
+  # そのまま渡されるのではなく、to_s した文字列相当がユーザから見える値になる。
+  class RuntimeError < StandardError
+  end
+
+  # def で定義した関数から return するための内部制御シグナル。
+  # 例外機構を使い、ネストしたif/forを一気に抜けて関数呼び出し境界まで戻る。
+  class ReturnSignal < StandardError
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+      super("return")
+    end
+  end
+
+  # redirect() 呼び出しでリクエスト処理を打ち切り、HTTPリダイレクトを行うための内部シグナル。
+  class RedirectSignal < StandardError
+    attr_reader :location
+
+    def initialize(location)
+      @location = location
+      super("redirect")
+    end
+  end
+end

data/lib/gemite/function.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gemite
+  # def name(params) ... end で定義された関数の実行時表現。
+  # closure_env には定義時点で有効だったEnvironmentを保持し、
+  # 関数内から外側(グローバル等)の変数を読み取れるようにする(代入は関数内ローカルに留まる)。
+  class Function
+    attr_reader :name, :params, :body, :closure_env
+
+    def initialize(name, params, body, closure_env)
+      @name = name
+      @params = params
+      @body = body
+      @closure_env = closure_env
+    end
+
+    def to_s
+      "<function #{name}>"
+    end
+  end
+end

data/lib/gemite/http_server.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "request"
+require_relative "router"
+require_relative "template_parser"
+require_relative "interpreter"
+require_relative "errors"
+
+module Gemite
+  # 依存ゼロ(Ruby標準の socket のみ)で実装した小規模開発用HTTPサーバ。
+  # .gmt ファイルはリクエストごとに読み直してパース・実行するため、
+  # 編集内容が即座に反映される(再起動不要)。
+  class HttpServer
+    def initialize(root:, port: 8000, host: "0.0.0.0")
+      @root = File.expand_path(root)
+      @port = port
+      @host = host
+      @router = Router.new(@root)
+    end
+
+    def start
+      $stdout.sync = true
+      server = TCPServer.new(@host, @port)
+      puts "Gemite dev server listening on http://localhost:#{@port}"
+      puts "root: #{@root}"
+      puts "(Ctrl-C で停止)"
+
+      trap("INT") do
+        puts "\nシャットダウンします..."
+        exit(0)
+      end
+
+      loop do
+        client = server.accept
+        Thread.new(client) { |c| handle_client(c) }
+      end
+    end
+
+    private
+
+    def handle_client(client)
+      request = read_request(client)
+      return unless request
+
+      handle_request(client, request)
+    rescue StandardError => e
+      begin
+        send_response(client, 500, "text/plain; charset=utf-8", "内部エラー: #{e.class}: #{e.message}")
+      rescue StandardError
+        nil
+      end
+    ensure
+      begin
+        client.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    def read_request(client)
+      request_line = client.gets
+      return nil if request_line.nil?
+
+      method, path, = request_line.strip.split(" ")
+      return nil unless method && path
+
+      headers = {}
+      loop do
+        line = client.gets
+        break if line.nil?
+
+        line = line.strip
+        break if line.empty?
+
+        key, val = line.split(":", 2)
+        next unless key && val
+
+        headers[key.strip.downcase] = val.strip
+      end
+
+      body = ""
+      len = headers["content-length"].to_i
+      body = client.read(len) if len.positive?
+
+      full_path, query_str = path.split("?", 2)
+      query_params = Request.parse_www_form(query_str || "")
+
+      Request.new(method: method, path: full_path, query_params: query_params, headers: headers, body: body)
+    rescue StandardError
+      nil
+    end
+
+    def handle_request(client, request)
+      result = @router.resolve(request.path)
+      case result.type
+      when :gemite
+        handle_gemite_request(client, result.path, request)
+      when :static
+        handle_static_request(client, result.path)
+      else
+        send_response(client, 404, "text/html; charset=utf-8", not_found_html(request.path))
+      end
+    end
+
+    def handle_gemite_request(client, file_path, request)
+      source = File.read(file_path, encoding: "UTF-8")
+      nodes = TemplateParser.parse(source)
+      interpreter = Interpreter.new(
+        get_params: request.query_params,
+        post_params: request.form_params,
+        base_dir: File.dirname(file_path)
+      )
+      html = interpreter.render(nodes)
+      send_response(client, 200, "text/html; charset=utf-8", html)
+    rescue Gemite::RedirectSignal => e
+      send_redirect(client, e.location)
+    rescue Gemite::SyntaxError, Gemite::RuntimeError => e
+      send_response(client, 500, "text/html; charset=utf-8", error_html(e, file_path))
+    rescue StandardError => e
+      send_response(client, 500, "text/html; charset=utf-8", error_html(e, file_path))
+    end
+
+    def handle_static_request(client, file_path)
+      data = File.binread(file_path)
+      send_response(client, 200, @router.mime_type_for(file_path), data, binary: true)
+    rescue StandardError => e
+      send_response(client, 500, "text/plain; charset=utf-8", "静的ファイルの読み込みに失敗しました: #{e.message}")
+    end
+
+    def send_response(client, status, content_type, body, binary: false)
+      bytes = binary ? body : body.to_s.b
+      status_text = STATUS_TEXT[status] || "Unknown"
+      client.write("HTTP/1.1 #{status} #{status_text}\r\n")
+      client.write("Content-Type: #{content_type}\r\n")
+      client.write("Content-Length: #{bytes.bytesize}\r\n")
+      client.write("Connection: close\r\n")
+      client.write("\r\n")
+      client.write(bytes)
+    end
+
+    def send_redirect(client, location)
+      client.write("HTTP/1.1 302 Found\r\n")
+      client.write("Location: #{location}\r\n")
+      client.write("Content-Length: 0\r\n")
+      client.write("Connection: close\r\n")
+      client.write("\r\n")
+    end
+
+    STATUS_TEXT = {
+      200 => "OK", 302 => "Found", 404 => "Not Found", 500 => "Internal Server Error"
+    }.freeze
+
+    def not_found_html(path)
+      <<~HTML
+        <!DOCTYPE html>
+        <html><head><meta charset="utf-8"><title>404 Not Found</title></head>
+        <body style="font-family: sans-serif; padding: 2rem;">
+        <h1>404 Not Found</h1>
+        <p><code>#{escape_html(path)}</code> に対応する .gmt ファイルが見つかりませんでした。</p>
+        </body></html>
+      HTML
+    end
+
+    def error_html(error, file_path)
+      <<~HTML
+        <!DOCTYPE html>
+        <html><head><meta charset="utf-8"><title>500 Internal Server Error</title></head>
+        <body style="font-family: sans-serif; padding: 2rem;">
+        <h1>500 Internal Server Error</h1>
+        <p><strong>#{escape_html(error.class.to_s)}</strong>: #{escape_html(error.message)}</p>
+        <p style="color:#666">ファイル: <code>#{escape_html(file_path)}</code></p>
+        </body></html>
+      HTML
+    end
+
+    def escape_html(str)
+      str.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+    end
+  end
+end