gemite 0.1.0

data/lib/gemite/sqlite3_ffi.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require "fiddle/import"
+require_relative "errors"
+
+module Gemite
+  # libsqlite3 (システムに標準で入っている共有ライブラリ) を Fiddle 経由で直接呼び出す
+  # 低レベル層。sqlite3 gem のようなネイティブ拡張のビルド(コンパイラやヘッダが必要)を
+  # 一切必要とせず、`gem install gemite` が即座に完了することを狙う。
+  module SQLite3FFI
+    SQLITE_OK = 0
+    SQLITE_ROW = 100
+    SQLITE_DONE = 101
+    SQLITE_TRANSIENT = -1
+
+    SQLITE_INTEGER = 1
+    SQLITE_FLOAT = 2
+    SQLITE_TEXT = 3
+    SQLITE_BLOB = 4
+    SQLITE_NULL = 5
+
+    # OS ごとの共有ライブラリ名の候補。最初に見つかったものを使う。
+    CANDIDATE_LIBS = [
+      "libsqlite3.so.0",
+      "libsqlite3.so",
+      "sqlite3.so",
+      "libsqlite3.dylib",
+      "sqlite3.dll"
+    ].freeze
+
+    module Lib
+      extend Fiddle::Importer
+    end
+
+    class LoadError < StandardError; end
+
+    def self.ensure_loaded!
+      return if @loaded
+
+      last_error = nil
+      CANDIDATE_LIBS.each do |name|
+        begin
+          Lib.dlload(name)
+          @loaded = name
+          break
+        rescue Fiddle::DLError => e
+          last_error = e
+        end
+      end
+
+      unless @loaded
+        raise LoadError,
+              "libsqlite3 が見つかりませんでした。システムに SQLite3 のランタイムライブラリ " \
+              "(libsqlite3-0 等) がインストールされているか確認してください。(#{last_error&.message})"
+      end
+
+      define_externs!
+    end
+
+    def self.define_externs!
+      Lib.extern "int sqlite3_open(const char*, void**)"
+      Lib.extern "int sqlite3_close(void*)"
+      Lib.extern "int sqlite3_prepare_v2(void*, const char*, int, void**, void**)"
+      Lib.extern "int sqlite3_step(void*)"
+      Lib.extern "int sqlite3_finalize(void*)"
+      Lib.extern "int sqlite3_bind_text(void*, int, const char*, int, void*)"
+      Lib.extern "int sqlite3_bind_int64(void*, int, long long)"
+      Lib.extern "int sqlite3_bind_double(void*, int, double)"
+      Lib.extern "int sqlite3_bind_null(void*, int)"
+      Lib.extern "int sqlite3_column_count(void*)"
+      Lib.extern "const char* sqlite3_column_name(void*, int)"
+      Lib.extern "int sqlite3_column_type(void*, int)"
+      Lib.extern "long long sqlite3_column_int64(void*, int)"
+      Lib.extern "double sqlite3_column_double(void*, int)"
+      Lib.extern "const char* sqlite3_column_text(void*, int)"
+      Lib.extern "const char* sqlite3_errmsg(void*)"
+      Lib.extern "long long sqlite3_last_insert_rowid(void*)"
+      Lib.extern "int sqlite3_changes(void*)"
+    end
+    private_class_method :define_externs!
+
+    # sqlite3* ハンドルと、その上での操作をまとめる薄いラッパー。
+    class Handle
+      def initialize(path)
+        SQLite3FFI.ensure_loaded!
+        @path = path
+        ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        rc = Lib.sqlite3_open(path, ptr)
+        @db = ptr.ptr
+        raise Gemite::RuntimeError, "データベース '#{path}' を開けませんでした" unless rc == SQLITE_OK
+      end
+
+      # 生のSQLを実行する(SELECT以外、あるいは戻り値を使わない用途)。
+      # ";" 区切りの複数文にも対応する。
+      def exec(sql)
+        remaining = sql
+        loop do
+          remaining = remaining.to_s
+          break if remaining.strip.empty?
+
+          stmt, tail = prepare_raw(remaining)
+          unless stmt
+            # このSQL断片に実行可能な文が含まれていなかった(空白・コメントのみ等)
+            break
+          end
+          step_all(stmt)
+          Lib.sqlite3_finalize(stmt)
+          remaining = tail
+        end
+        nil
+      end
+
+      # SELECT文を実行し、行の配列(各行は列名Symbol => 値 のHash)を返す。
+      def query(sql, params = [])
+        stmt, = prepare_raw(sql)
+        raise Gemite::RuntimeError, "SQL準備に失敗しました: #{last_error}" unless stmt
+
+        bind_params(stmt, params)
+        rows = []
+        col_count = Lib.sqlite3_column_count(stmt)
+        col_names = Array.new(col_count) { |i| Lib.sqlite3_column_name(stmt, i).to_s.to_sym }
+
+        while Lib.sqlite3_step(stmt) == SQLITE_ROW
+          row = {}
+          col_count.times do |i|
+            row[col_names[i]] = read_column(stmt, i)
+          end
+          rows << row
+        end
+        Lib.sqlite3_finalize(stmt)
+        rows
+      end
+
+      # INSERT/UPDATE/DELETE等、戻り値の行を必要としない文を実行する。
+      # {rowid:, changes:} を返す。
+      def execute(sql, params = [])
+        stmt, = prepare_raw(sql)
+        raise Gemite::RuntimeError, "SQL準備に失敗しました: #{last_error}" unless stmt
+
+        bind_params(stmt, params)
+        rc = Lib.sqlite3_step(stmt)
+        Lib.sqlite3_finalize(stmt)
+        unless rc == SQLITE_DONE
+          raise Gemite::RuntimeError, "SQL実行に失敗しました: #{last_error}"
+        end
+
+        { rowid: Lib.sqlite3_last_insert_rowid(@db), changes: Lib.sqlite3_changes(@db) }
+      end
+
+      def close
+        Lib.sqlite3_close(@db) if @db
+        @db = nil
+      end
+
+      private
+
+      def last_error
+        Lib.sqlite3_errmsg(@db).to_s
+      end
+
+      # 1文だけprepareする。戻り値は [stmt_ptr_or_nil, tail_sql_string]。
+      def prepare_raw(sql)
+        stmt_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        tail_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        sql_str = sql.to_s
+        rc = Lib.sqlite3_prepare_v2(@db, sql_str, sql_str.bytesize, stmt_ptr, tail_ptr)
+        raise Gemite::RuntimeError, "SQL構文エラー: #{last_error}" unless rc == SQLITE_OK
+
+        stmt = stmt_ptr.ptr
+        tail_addr = tail_ptr.ptr
+        tail = tail_addr.null? ? "" : tail_addr.to_s
+        [stmt.null? ? nil : stmt, tail]
+      end
+
+      def step_all(stmt)
+        loop do
+          rc = Lib.sqlite3_step(stmt)
+          break if rc == SQLITE_DONE
+          break if rc == SQLITE_ROW # execで結果行が来ても単に読み捨てる
+
+          unless [SQLITE_DONE, SQLITE_ROW].include?(rc)
+            raise Gemite::RuntimeError, "SQL実行に失敗しました: #{last_error}"
+          end
+        end
+      end
+
+      def bind_params(stmt, params)
+        params.each_with_index do |val, idx|
+          i = idx + 1
+          case val
+          when nil
+            Lib.sqlite3_bind_null(stmt, i)
+          when true
+            Lib.sqlite3_bind_int64(stmt, i, 1)
+          when false
+            Lib.sqlite3_bind_int64(stmt, i, 0)
+          when Integer
+            Lib.sqlite3_bind_int64(stmt, i, val)
+          when Float
+            Lib.sqlite3_bind_double(stmt, i, val)
+          else
+            s = val.to_s
+            bytes = s.b
+            Lib.sqlite3_bind_text(stmt, i, s, bytes.bytesize, SQLITE_TRANSIENT)
+          end
+        end
+      end
+
+      def read_column(stmt, idx)
+        type = Lib.sqlite3_column_type(stmt, idx)
+        case type
+        when SQLITE_INTEGER then Lib.sqlite3_column_int64(stmt, idx)
+        when SQLITE_FLOAT then Lib.sqlite3_column_double(stmt, idx)
+        when SQLITE_TEXT
+          raw = Lib.sqlite3_column_text(stmt, idx)
+          raw.nil? ? nil : raw.to_s.dup.force_encoding("UTF-8")
+        else nil # SQLITE_NULL, SQLITE_BLOB(未対応)
+        end
+      end
+    end
+  end
+end

data/lib/gemite/template_parser.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative "ast"
+require_relative "parser"
+require_relative "errors"
+
+module Gemite
+  # .tz ファイルの生テキストを走査し、以下のノード列(木)を組み立てる:
+  #   TplText  - そのまま出力する生HTML
+  #   TplExpr  - { expr } 補間。式の評価結果を文字列化して出力する
+  #   TplCode  - <?gemite ... ?> ブロック。中身は文として実行するだけで出力はしない
+  #   TplIf    - @if/@elseif/@else/@endif (HTML側)。分岐に応じて子ノードを出力する
+  #   TplFor   - @for x in xs ... @end (HTML側)。反復して子ノードを出力する
+  #
+  # <?gemite ?> の中身、および @if/@for がコードブロック内で使われた場合は、
+  # Parser(文パーサー)側に委譲する。@if/@endif, @for/@end はテンプレート層・
+  # コード層の両方に現れうるが、defやbeginの素のendはコード層にしか現れない。
+  class TemplateParser
+    include AST
+
+    # コードブロックの開始タグ。文字数に依存する処理はすべてこの定数の
+    # .length から動的に算出し、名称変更があってもズレないようにする。
+    CODE_TAG_OPEN = "<?gemite"
+    CODE_TAG_CLOSE = "?>"
+
+    # @if/@elseif/@for は条件式・イテラブル式(行の残り)を伴う。
+    # @else/@endif/@end は節を取らないので、キーワード自体だけを消費する
+    # (でないと同じ行に続くHTMLや<?gemite ?>を誤って飲み込んでしまう)。
+    # 行頭(前後の空白のみ許容)に限定することで、HTML本文中の"@"(メールアドレス等)との衝突も避ける。
+    DIRECTIVE_WITH_CLAUSE = /\A[ \t]*@(if|elseif|for)\b[ \t]*(.*)\z/
+    DIRECTIVE_BARE = /\A[ \t]*@(else|endif|end)\b[ \t]*/
+
+    def self.parse(source)
+      new(source).parse_nodes(nil)
+    end
+
+    def initialize(source)
+      @src = source
+      @pos = 0
+      @len = source.length
+      @line = 1
+    end
+
+    # stop_directives: nilならEOFまで。配列ならそのディレクティブ名(文字列)に
+    # 出会うまで(消費はしない。呼び出し元がexpectする)。
+    def parse_nodes(stop_directives)
+      nodes = []
+      text_buf = +""
+      text_start_line = @line
+
+      flush = lambda do
+        unless text_buf.empty?
+          nodes << TplText.new(text_buf)
+          text_buf = +""
+        end
+      end
+
+      until eof?
+        # <?gemite ... ?> コードブロック
+        if looking_at?(CODE_TAG_OPEN)
+          flush.call
+          nodes << parse_code_block
+          text_start_line = @line
+          next
+        end
+
+        # { expr } 補間 (失敗したら生テキストとしてフォールバック)
+        if peek_char == "{"
+          expr_node = try_parse_interpolation
+          if expr_node
+            flush.call
+            nodes << expr_node
+            text_start_line = @line
+            next
+          end
+        end
+
+        # 行頭ディレクティブ (@if/@elseif/@else/@endif/@for/@end)
+        if at_line_start?
+          directive, clause, consumed_len = peek_directive_at_current_line
+          if directive
+            if stop_directives && stop_directives.include?(directive)
+              # ここでは消費しない。呼び出し元が consume_matched_directive で読み進める。
+              flush.call
+              return nodes
+            end
+
+            consume_chars(consumed_len)
+
+            case directive
+            when "if"
+              flush.call
+              nodes << parse_template_if(clause)
+              text_start_line = @line
+              next
+            when "for"
+              flush.call
+              nodes << parse_template_for(clause)
+              text_start_line = @line
+              next
+            when "elseif", "else", "endif", "end"
+              # 対応する開始ディレクティブなしに出現した閉じ/中間ディレクティブ
+              raise Gemite::SyntaxError.new("対応する開始タグのない '@#{directive}' です", line: @line)
+            end
+          end
+        end
+
+        ch = advance_char
+        text_buf << ch
+      end
+
+      if stop_directives
+        raise Gemite::SyntaxError.new(
+          "'#{stop_directives.map { |d| "@#{d}" }.join("/")}' が見つからないまま終端しました",
+          line: text_start_line
+        )
+      end
+
+      flush.call
+      nodes
+    end
+
+    private
+
+    def eof?
+      @pos >= @len
+    end
+
+    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 looking_at?(str)
+      @src[@pos, str.length] == str
+    end
+
+    # 現在位置が「行頭」(直前が改行かファイル先頭)かどうか
+    def at_line_start?
+      @pos.zero? || @src[@pos - 1] == "\n"
+    end
+
+    # 現在行(行頭からの残り)が @if/@elseif/... のディレクティブ行かどうかを、
+    # 文字を消費せずに調べる。マッチした場合、ディレクティブ名・節の文字列
+    # (条件式など。@else/@endif/@endの場合は空文字列)・マッチした長さ(文字数)を返す。
+    def peek_directive_at_current_line
+      line_end = @src.index("\n", @pos) || @len
+      line_text = @src[@pos...line_end]
+
+      m = DIRECTIVE_WITH_CLAUSE.match(line_text)
+      return [m[1], m[2].to_s.strip, m[0].length] if m
+
+      m = DIRECTIVE_BARE.match(line_text)
+      return [m[1], "", m[0].length] if m
+
+      [nil, nil, 0]
+    end
+
+    def consume_chars(n)
+      n.times { advance_char }
+    end
+
+    def parse_code_block
+      start_line = @line
+      consume_chars(CODE_TAG_OPEN.length)
+      code_start_pos = @pos
+      code_start_line = @line
+      close_idx = @src.index(CODE_TAG_CLOSE, @pos)
+      unless close_idx
+        raise Gemite::SyntaxError.new("#{CODE_TAG_OPEN} ブロックが '#{CODE_TAG_CLOSE}' で閉じられていません", line: start_line)
+      end
+
+      code_src = @src[code_start_pos...close_idx]
+      advance_char while @pos < close_idx
+      consume_chars(CODE_TAG_CLOSE.length)
+
+      statements = Gemite::Parser.parse_statements_from_source(code_src, line: code_start_line)
+      TplCode.new(statements)
+    end
+
+    # { ... } を式として解析する。対応する } を探すために深さと文字列リテラルを
+    # 追跡する。パースに失敗、または対応する } が見つからない場合は nil を返し、
+    # 呼び出し元は "{" を通常のテキスト文字として扱う(CSS等の { } との衝突回避)。
+    def try_parse_interpolation
+      saved_pos = @pos
+      saved_line = @line
+
+      advance_char # '{'
+      depth = 1
+      in_str = false
+      buf = +""
+
+      loop do
+        ch = peek_char
+        if ch.nil?
+          @pos = saved_pos
+          @line = saved_line
+          return nil
+        end
+
+        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
+        when "\n"
+          # 補間は基本1行で完結する想定。複数行にまたがる場合は生テキスト扱いにする
+          # (CSSブロック等をより安全側に倒すため)。
+          @pos = saved_pos
+          @line = saved_line
+          return nil
+        else
+          buf << ch
+          advance_char
+        end
+      end
+
+      begin
+        expr = Gemite::Parser.parse_expression_from_source(buf, line: saved_line)
+        TplExpr.new(expr)
+      rescue Gemite::SyntaxError
+        @pos = saved_pos
+        @line = saved_line
+        nil
+      end
+    end
+
+    def parse_template_if(first_clause_src)
+      branches = []
+      cond = Gemite::Parser.parse_expression_from_source(first_clause_src, line: @line)
+      body = parse_nodes(%w[elseif else endif])
+      branches << [cond, body]
+
+      loop do
+        directive, clause = consume_matched_directive
+        case directive
+        when "elseif"
+          c = Gemite::Parser.parse_expression_from_source(clause, line: @line)
+          b = parse_nodes(%w[elseif else endif])
+          branches << [c, b]
+        when "else"
+          else_body = parse_nodes(%w[endif])
+          consume_matched_directive # endif
+          return TplIf.new(branches, else_body)
+        when "endif"
+          return TplIf.new(branches, nil)
+        end
+      end
+    end
+
+    def parse_template_for(clause_src)
+      var_name, iterable = Gemite::Parser.parse_for_clause_from_source(clause_src, line: @line)
+      body = parse_nodes(%w[end])
+      consume_matched_directive # end
+      TplFor.new(var_name, iterable, body)
+    end
+
+    # parse_nodes が stop_directives に当たって(消費せずに)return した直後、
+    # その行頭ディレクティブを実際に読み進めるためのヘルパー。
+    def consume_matched_directive
+      raise Gemite::SyntaxError.new("内部エラー: ディレクティブ行が見つかりません", line: @line) unless at_line_start?
+
+      directive, clause, consumed_len = peek_directive_at_current_line
+      raise Gemite::SyntaxError.new("内部エラー: ディレクティブの再マッチに失敗しました", line: @line) unless directive
+
+      consume_chars(consumed_len)
+      [directive, clause]
+    end
+  end
+end

data/lib/gemite/token.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Gemite
+  # 字句解析の最小単位。type はSymbol、value はトークン種別ごとの実値、
+  # line はエラーメッセージ用の行番号。
+  Token = Struct.new(:type, :value, :line) do
+    def to_s
+      "#<Token #{type}:#{value.inspect} @#{line}>"
+    end
+  end
+end

data/lib/gemite/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gemite
+  VERSION = "0.1.0"
+end

data/lib/gemite.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "gemite/version"
+require_relative "gemite/errors"
+require_relative "gemite/token"
+require_relative "gemite/lexer"
+require_relative "gemite/ast"
+require_relative "gemite/parser"
+require_relative "gemite/environment"
+require_relative "gemite/template_parser"
+require_relative "gemite/function"
+require_relative "gemite/sqlite3_ffi"
+require_relative "gemite/database"
+require_relative "gemite/interpreter"
+require_relative "gemite/request"
+require_relative "gemite/router"
+require_relative "gemite/http_server"
+require_relative "gemite/cli"
+
+module Gemite
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: gemite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Araki-Tomoya
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Gemite is a lightweight HTML-first programming language inspired by PHP.
+  It allows developers to build dynamic web applications with minimal setup,
+  built-in routing based on file structure, and integrated SQLite support.
+executables:
+- gemite
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- examples/comments/README.md
+- examples/comments/index.gmt
+- examples/comments/public/css/style.css
+- exe/gemite
+- lib/gemite.rb
+- lib/gemite/ast.rb
+- lib/gemite/cli.rb
+- lib/gemite/database.rb
+- lib/gemite/environment.rb
+- lib/gemite/errors.rb
+- lib/gemite/function.rb
+- lib/gemite/http_server.rb
+- lib/gemite/interpreter.rb
+- lib/gemite/lexer.rb
+- lib/gemite/parser.rb
+- lib/gemite/request.rb
+- lib/gemite/router.rb
+- lib/gemite/sqlite3_ffi.rb
+- lib/gemite/template_parser.rb
+- lib/gemite/token.rb
+- lib/gemite/version.rb
+homepage: https://github.com/SrinivasaRimskyYamatov/gemite
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/SrinivasaRimskyYamatov/gemite
+  source_code_uri: https://github.com/SrinivasaRimskyYamatov/gemite
+  bug_tracker_uri: https://github.com/SrinivasaRimskyYamatov/gemite/issues
+  changelog_uri: https://github.com/SrinivasaRimskyYamatov/gemite/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.14
+specification_version: 4
+summary: HTML-first language for small web applications
+test_files: []