eks-cent 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67ef903d9f6fc46bb7f71450367a2fb7f8e7c278467e1124c33944ee1799486b
-  data.tar.gz: 602f77e111762d9b6a9713e5fd5547cd1dce06c972abedafa22db9b3e88fe7c9
+  metadata.gz: 2ed494c921a2bb36933450d69a731cc504340a404d3b101224a5247b81f99666
+  data.tar.gz: 8f99a004701ac50d66be5db2385dfb01ad57860eb78ce67ec38d1dbe5be2d54a
 SHA512:
-  metadata.gz: 035074f92c6cca99e6ae40dbdc8e526ea3498f2a4cc4b535b5a3c8f8311c2b11cd4c76d4fec8e05e3924ad8909867f273d26964fbd81bf28783f43fbe8fdf1af
-  data.tar.gz: 010e6e4519f6a5d50231aa457f2d0fc1ec4f655788247179b8b94d4c739507007148fcb0f0c5a253c903b45af667a81e0671f76634fff807bb6fd4cb1b6b85a0
+  metadata.gz: babec8d09352ead4578f627d0e9cd69d57d234e6e2d3d6f7471884ec424354a84270ae8ad80b10f855862d973517ae8da4aaa4d59dfdb9d6d8194a3fbbe5d983
+  data.tar.gz: d77626acdc60cb91342839ac4c73c533adaa6b4d37c38c581ba23f75e5e22ea0b8246fb1e850f68ad6bc92a689573d0da272869f65199cacc6cad5f0804ec226

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog - Eks-Cent
+
+Semua perubahan penting pada proyek ini akan didokumentasikan dalam file ini.
+
+## [4.0.0] - 2026-03-31
+
+Rilis Major dengan peningkatan arsitektural signifikan dan fitur standar Eks Interface.
+
+### Ditambahkan
+- **URL Mapping (`map`)**: Memungkinkan menjalankan beberapa aplikasi di bawah jalur URL yang berbeda.
+- **Application Cascade**: Mekanisme fallback otomatis antar aplikasi jika terjadi 404.
+- **Middleware Baru**:
+  - `EksCent::Middleware::Runtime`: Header `X-Runtime` untuk pelacakan performa.
+  - `EksCent::Middleware::MethodOverride`: Dukungan method HTTP non-GET/POST via parameter `_method`.
+  - `EksCent::Middleware::Head`: Penanganan otomatis permintaan `HEAD`.
+- **Keamanan**: Batasan parameter (`EKS_QUERY_PARSER_PARAMS_LIMIT` dan `EKS_MULTIPART_TOTAL_PART_LIMIT`) untuk mitigasi serangan DoS.
+- **Helper Respons**: Menambahkan metode `set_header` dan `content_type=` pada kelas `Response`.
+- **Mock Testing**: Objek `MockResponse` yang lebih kaya fitur untuk pengujian unit.
+
+### Diubah
+- **Response Layout**: Sistem layout ERB kini mendeteksi `views/layout.erb` secara otomatis.
+- **Error Handling**: Peningkatan UI pada middleware `ShowExceptions`.
+- **CLI**: Perbaikan logika auto-reload pada `ekscentup -R`.
+
+---
+
+## [1.0.0] - [3.0.0] - 2026-03-28
+
+Peningkatan stabilitas dan fitur pendukung rute.
+
+### Ditambahkan
+- Dukungan `multipart/form-data` menggunakan `Eks Standard Request` secara internal.
+- Mekanisme `halt` di Router menggunakan `catch/throw`.
+- Custom `not_found` dan `error` DSL di Router.
+- Injeksi objek `@req` dan `@res` ke dalam template ERB.

data/README.md

@@ -1,106 +1,188 @@
-# Eks-Cent Framework 🚀
+<p align="center">
+  <img src="images/logo.webp" alt="Eks-Cent Logo" width="200" />
+</p>
 
-**Eks-Cent** adalah framework web Ruby ringan yang terinspirasi oleh Rack. Dirancang untuk kecepatan, keamanan, dan kemudahan penggunaan tanpa dependensi eksternal yang berat.
+# Eks-Cent Framework v4.0.0 🚀
 
-Eks-Cent menggunakan **Eksa-Server** sebagai engine server bawaan untuk performa tinggi di lingkungan produksi.
+**Eks-Cent** adalah framework web Ruby modern yang ringan, menggunakan standar **Eks Interface**. Dirancang untuk kecepatan, keamanan tingkat tinggi, dan fleksibilitas tanpa beban dependensi eksternal yang besar. Dengan v4.0.0, Eks-Cent kini mendukung fitur arsitektural canggih seperti **URL Mapping** dan **Application Cascading**.
 
-## ✨ Fitur Utama
+---
 
-- 🛤 **Advanced Routing**: DSL rute yang bersih dengan dukungan parameter dinamis dan namespace.
-- 🔐 **Security Pack**:
-  - **Signed Sessions**: Data session aman dengan HMAC-SHA256.
-  - **XSS Protection**: Helper `h` otomatis untuk escape HTML di template.
-  - **Security Headers**: Middleware bawaan untuk header Frame-Options, XSS-Protection, dll.
-- 🎨 **Templating**: Integrasi native dengan **ERB** (Embedded Ruby).
-- 📦 **JSON Ready**: Parsing otomatis untuk request body `application/json`.
-- ⚡ **High Performance**: Terintegrasi dengan Eksa-Server (Cluster mode & Workers).
-- 🛠 **CLI Tool**: Jalankan aplikasi dengan perintah `ekscentup` layaknya `rackup`.
+## ✨ Fitur Utama v4.0.0
 
-## 📦 Instalasi
+- 🛤 **Modern Routing DSL**: Pendefinisian rute yang intuitif dengan parameter dinamis (`:name`), namespace, dan kontrol eksekusi (`halt`).
+- 🗺 **URL Mapping & Cascading**: Jalankan beberapa aplikasi independen di bawah satu server berdasarkan sub-jalur (path mapping) atau fallback otomatis.
+- 🔐 **Security First**: Session terenkripsi HMAC-SHA256, proteksi XSS otomatis, header keamanan bawaan, dan pembatasan parameter (DoS protection).
+- 🛠 **Standard Middleware Suite**:
+  - `Runtime`: Pantau performa dengan header `X-Runtime`.
+  - `MethodOverride`: Gunakan `PUT/DELETE` dari form HTML biasa.
+  - `Head`: Otomatisasi penanganan request `HEAD`.
+  - `Session`, `Logger`, `Static`, `ShowExceptions`, dll.
+- 🎨 **Smart Templating**: Integrasi **ERB** dengan sistem **Auto-Layout**, injeksi objek `@req`/`@res`, dan helper keamanan `h`.
+- 🧪 **First-Class Testing**: Infrastruktur pengujian bawaan menggunakan `MockRequest` dan `MockResponse`.
+- ⚡ **Production Ready**: Terintegrasi penuh dengan **Eksa-Server** (Cluster mode & Workers) dan CLI tool `ekscentup`.
 
-Tambahkan baris ini ke dalam Gemfile aplikasi Anda:
+---
 
-```ruby
-gem 'eks-cent'
-```
-
-Lalu jalankan:
-```bash
-gem install eks-cent
-```
-
-## 🚀 Memulai Cepat
+## 🚀 Memulai Cepat (v4 Style)
 
-Buat file bernama `config.eks`:
+Buat file `config.eks` untuk mendefinisikan aplikasi Anda:
 
 ```ruby
-# config.eks
-use EksCent::Middleware::ContentSecurity
+# 1. Global Middlewares
+use EksCent::Middleware::Runtime
+use EksCent::Middleware::MethodOverride
 use EksCent::Middleware::Session
 use EksCent::Middleware::Logger
-use EksCent::Middleware::ShowExceptions
 
+# 2. Pemetaan Aplikasi API
+map "/api" do
+  api = EksCent::Router.new do
+    get '/status' do |req, res|
+      res.content_type = 'application/json'
+      res.write({ status: 'online', version: EksCent::VERSION }.to_json)
+    end
+  end
+  run api
+end
+
+# 3. Aplikasi Web Utama
 router = EksCent::Router.new do
-  # Halaman Utama
   get '/' do |req, res|
     req.session['visits'] ||= 0
     req.session['visits'] += 1
-    res.write "<h1>Halo! Anda sudah berkunjung #{req.session['visits']} kali.</h1>"
+    res.write "<h1>Web Utama v#{EksCent::VERSION}</h1>"
+    res.write "<p>Kunjungan Anda: #{req.session['visits']}</p>"
   end
+end
 
-  # Rute Dinamis
-  get '/hello/:name' do |req, res|
-    res.render 'welcome', name: req.params['name']
+run router
+```
+
+Jalankan dengan perintah:
+```bash
+ekscentup -R --port 3000
+```
+
+---
+
+## 🛤 Dokumentasi Routing
+
+### Router DSL
+Anda dapat mendefinisikan rute menggunakan metode HTTP standar (`get`, `post`, `put`, `delete`, `patch`, `options`, `any`).
+
+```ruby
+router = EksCent::Router.new do
+  get '/user/:id' do |req, res|
+    id = req.params['id']
+    res.write "User ID: #{id}"
   end
 
-  # API JSON
-  namespace '/api' do
-    post '/data' do |req, res|
-      res.headers['Content-Type'] = 'application/json'
-      res.write({ status: 'success', data: req.params }.to_json)
+  namespace '/admin' do
+    get '/dashboard' do |req, res|
+      # Diakses via /admin/dashboard
     end
   end
+  
+  # Kontrol Eksekusi
+  get '/secret' do |req, res|
+    halt(403, "Akses ditolak") unless req.session['admin']
+    res.write "Data Rahasia"
+  end
 end
+```
 
-run router
+### URL Mapping & Cascade
+Gunakan `map` untuk membagi aplikasi besar menjadi sub-aplikasi yang lebih kecil. Gunakan `cascade` jika Anda ingin mencoba beberapa aplikasi secara bergantian hingga ada yang merespons (selain 404).
+
+---
+
+## 📦 Middleware Bawaan
+
+| Middleware | Deskripsi |
+|------------|-----------|
+| `EksCent::Middleware::Runtime` | Menambahkan header `X-Runtime` dengan waktu eksekusi. |
+| `EksCent::Middleware::MethodOverride` | Mengizinkan override method HTTP via parameter `_method`. |
+| `EksCent::Middleware::Session` | Manajemen session aman berbasis cookie dengan HMAC. |
+| `EksCent::Middleware::Logger` | Logging permintaan ke STDOUT atau file log. |
+| `EksCent::Middleware::Static` | Melayani file statis dari direktori tertentu (misal: `public`). |
+| `EksCent::Middleware::ShowExceptions` | Menampilkan halaman error yang informatif saat terjadi *crash*. |
+| `EksCent::Middleware::ContentSecurity` | Menambahkan header keamanan standar (X-Content-Type, X-Frame-Options). |
+| `EksCent::Middleware::Head` | Mengosongkan body untuk request HEAD secara otomatis. |
+
+---
+
+## 🎨 Templating & Layout
+
+Letakkan file `.erb` Anda di dalam direktori `views/`. Secara otomatis, framework akan mencari `views/layout.erb` sebagai pembungkus utama.
+
+**views/layout.erb**:
+```erb
+<html>
+  <body>
+    <header>My App</header>
+    <%= @content %> <!-- Konten dari render akan disisipkan di sini -->
+  </body>
+</html>
 ```
 
-Jalankan server:
-```bash
-./bin/ekscentup -p 3000
+Di dalam Router:
+```ruby
+res.render 'index', judul: "Halo Dunia"
 ```
 
-## 🛠 Penggunaan CLI (`ekscentup`)
+**Context Injection**: Objek `@req` (request) dan `@res` (response) serta helper `@h` (escape HTML) selalu tersedia di dalam template.
 
-| Opsi | Deskripsi |
-|------|-----------|
-| `-p, --port` | Menentukan port server (default: 3000) |
-| `-o, --host` | Menentukan host server (default: 0.0.0.0) |
-| `-w, --workers` | Jumlah worker untuk mode Cluster |
-| `-R, --reload` | Aktifkan auto-reload saat file berubah |
-| `-e, --env` | Set lingkungan (`development` atau `production`) |
-| `-L, --log` | Simpan log ke file tertentu |
+---
 
-## 🛡 Mode Produksi
+## 🛠 Panduan API (Request & Response)
 
-Untuk keamanan maksimal di produksi, pastikan Anda menyetel environment variable dan secret key:
+### EksCent::Request (`req`)
+- `req.params`: Mengambil parameter query, POST, atau route params.
+- `req.session`: Mengakses data session (Read/Write).
+- `req.request_method`: Mendapatkan method HTTP (GET, POST, dll).
+- `req.path`: Mendapatkan jalur URL saat ini.
+- `req.user_agent`: Mendapatkan informasi browser.
 
-```bash
-export EKS_CENT_SECRET_KEY_BASE="kunci_rahasia_anda_yang_unik"
-export RACK_ENV=production
-./bin/ekscentup -p 80 -e production
-```
+### EksCent::Response (`res`)
+- `res.write(string)`: Menambahkan konten ke body respons.
+- `res.set_header(key, value)`: Mengatur header HTTP.
+- `res.content_type = 'type'`: Shortcut untuk mengatur Content-Type.
+- `res.status = code`: Mengatur status code (default: 200).
+- `res.redirect(path)`: Melakukan pengalihan URL.
+- `res.render(template, locals)`: Merender template ERB.
 
-## 🧪 Pengujian
+---
 
-Eks-Cent dilengkapi dengan suite pengujian yang lengkap. Untuk menjalankan semua tes:
+## 🧪 Pengujian (Testing)
 
-```bash
-ruby test/eks_cent_test.rb
-ruby test/router_test.rb
-ruby test/security_test.rb
+Gunakan suite pengujian bawaan untuk memastikan aplikasi Anda berjalan dengan benar:
+
+```ruby
+require 'test/unit'
+require 'eks-cent'
+
+class MyAppTest < Test::Unit::TestCase
+  def test_homepage
+    app = EksCent.load('config.eks')
+    mock = EksCent::MockRequest.new(app)
+    
+    res = mock.get('/')
+    assert res.ok?
+    assert_match "Welcome", res.body_content
+  end
+end
 ```
 
-## 📄 Lisensi
+---
+
+## 🛡 Keamanan Dasar (Eks Limits)
+Anda dapat mengatur batasan penguraian parameter melalui variabel lingkungan untuk mencegah serangan DoS:
+- `EKS_QUERY_PARSER_PARAMS_LIMIT`: Maksimal jumlah parameter (default: 1000).
+- `EKS_QUERY_PARSER_DEPTH_LIMIT`: Maksimal kedalaman parameter nested.
+- `EKS_MULTIPART_TOTAL_PART_LIMIT`: Maksimal part dalam form multipart.
 
-Eks-Cent didistribusikan di bawah [Lisensi MIT](LICENSE).
+---
+
+## 📄 Lisensi
+Eks-Cent v4.0.0 dipublikasikan di bawah [Lisensi MIT](LICENSE).

data/bin/ekscentup

@@ -22,7 +22,7 @@ options = {
   workers: 0,
   reload: false,
   timeout: 30,
-  env: ENV['RACK_ENV'] || 'development'
+  env: ENV['EKS_ENV'] || ENV['RACK_ENV'] || 'development'
 }
 
 OptionParser.new do |opts|
@@ -56,7 +56,7 @@ OptionParser.new do |opts|
 
   opts.on("-e", "--env ENV", "Set environment (development/production)") do |v|
     options[:env] = v
-    ENV['RACK_ENV'] = v
+    ENV['EKS_ENV'] = v
   end
 
   opts.on("-v", "--version", "Tampilkan versi Eks-Cent") do
@@ -99,22 +99,86 @@ end
 
 puts "\e[34m[Eks-Cent] Environment: #{EksCent.env}\e[0m"
 
-# Load aplikasi via Builder
-begin
-  app = EksCent.load(config_path)
-rescue => e
-  puts "\e[31mGagal memuat aplikasi: #{e.message}\e[0m"
-  puts e.backtrace.first(5).join("\n")
-  exit 1
+# Fungsi untuk menjalankan server
+def start_server(config_path, options)
+  begin
+    # Load aplikasi via Builder di setiap start agar config direfresh
+    app = EksCent.load(config_path)
+    server = EksaServerCore.new(app, options.merge(reload: false))
+    server.start
+  rescue Interrupt
+    # Biarkan parent menangani Interrupt
+    exit 0
+  rescue => e
+    puts "\e[31m[Eks-Cent] Server error: #{e.message}\e[0m"
+    puts e.backtrace.first(5).join("\n")
+    exit 1
+  end
 end
 
-# Jalankan menggunakan EksaServerCore
-begin
-  server = EksaServerCore.new(app, options)
-  server.start
-rescue Interrupt
-  puts "\n\e[33mMenutup server Eks-Cent...\e[0m"
-rescue => e
-  puts "\e[31mServer error: #{e.message}\e[0m"
-  exit 1
+if options[:reload] && Process.respond_to?(:fork)
+  puts "\e[34m[Eks-Cent] Auto-reload aktif. Memantau perubahan file di direktori ini...\e[0m"
+  
+  trap("INT") do
+    puts "\n\e[33mMenutup Reloader Eks-Cent...\e[0m"
+    Process.kill("INT", @child_pid) rescue nil if @child_pid
+    exit 0
+  end
+
+  loop do
+    @child_pid = fork do
+      start_server(config_path, options)
+    end
+
+    # Pemantau file sederhana (cek mtime setiap detik)
+    watched_extensions = %w[.rb .eks .erb .html .css .js]
+    initial_mtimes = {}
+    
+    # Inisialisasi daftar file
+    Dir.glob("**/*").each do |f|
+      next unless watched_extensions.include?(File.extname(f))
+      initial_mtimes[f] = File.mtime(f) rescue nil
+    end
+
+    loop do
+      sleep 1
+      
+      # Periksa perubahan
+      changed = false
+      Dir.glob("**/*").each do |f|
+        next unless watched_extensions.include?(File.extname(f))
+        current_mtime = File.mtime(f) rescue nil
+        if current_mtime && (!initial_mtimes[f] || current_mtime > initial_mtimes[f])
+          changed = true
+          break
+        end
+      end
+
+      if changed
+        puts "\e[34m[Reloader] Perubahan terdeteksi. Me-restart server...\e[0m"
+        Process.kill("INT", @child_pid) rescue nil
+        Process.wait(@child_pid) rescue nil
+        break # Keluar ke loop untuk fork baru
+      end
+
+      # Cek jika proses anak berhenti mendadak
+      if (pid = Process.waitpid(@child_pid, Process::WNOHANG))
+        puts "\e[31m[Reloader] Server (PID: #{pid}) berhenti. Me-restart dalam 2 detik...\e[0m"
+        sleep 2
+        break
+      end
+    end
+  end
+else
+  # Mode Standar (Tanpa Reload)
+  begin
+    app = EksCent.load(config_path)
+    server = EksaServerCore.new(app, options)
+    server.start
+  rescue Interrupt
+    puts "\n\e[33mMenutup server Eks-Cent...\e[0m"
+  rescue => e
+    puts "\e[31mServer error: #{e.message}\e[0m"
+    exit 1
+  end
 end

data/config.eks

@@ -1,44 +1,50 @@
 # File: config.eks
-# Contoh konfigurasi untuk Eks-Cent
+# Contoh konfigurasi lanjutan untuk Eks-Cent v4.0.0
 
+# 1. Globals & Security Middlewares
+use EksCent::Middleware::Runtime         # Header X-Runtime otomatis
+use EksCent::Middleware::Head            # Penanganan HEAD request otomatis
+use EksCent::Middleware::MethodOverride  # Dukungan _method=DELETE/PUT via form
 use EksCent::Middleware::ContentSecurity
 use EksCent::Middleware::Session
-use EksCent::Middleware::Static, root: 'public'
 use EksCent::Middleware::Logger
 use EksCent::Middleware::ShowExceptions
 
-# Aplikasi Utama
-# Aplikasi Utama menggunakan Router
-router = EksCent::Router.new do
+# 2. Aplikasi API (Dipetakan ke /api)
+map "/api" do
+  router_api = EksCent::Router.new do
+    get "/status" do |req, res|
+      res.set_header 'Content-Type', 'application/json'
+      res.write "{\"status\": \"online\", \"version\": \"#{EksCent::VERSION}\"}"
+    end
+    
+    put "/update" do |req, res|
+      res.write "Method PUT diterima (via MethodOverride). Method asli: #{req.env['eks_cent.original_method']}"
+    end
+  end
+  run router_api
+end
+
+# 3. Aplikasi Web Utama (Dipetakan ke root /)
+router_web = EksCent::Router.new do
   get '/' do |req, res|
-    # Contoh penggunaan session
     req.session['visits'] ||= 0
     req.session['visits'] += 1
     
-    res.write "<h1>Selamat Datang di Eks-Cent!</h1>"
-    res.write "<p>Ini adalah framework tanpa dependensi.</p>"
-    res.write "<p>Jumlah kunjungan Anda: <strong>#{req.session['visits']}</strong></p>"
-    res.write "<p>Cobalah akses <a href='/error'>/error</a> untuk melihat middleware ShowExceptions.</p>"
-  end
-
-  get '/welcome' do |req, res|
-    # Contoh penggunaan ERB rendering dan h helper
-    res.render 'test', name: req.params['name'] || 'Tamu'
-  end
-
-  get '/hello/:name' do |req, res|
-    name = req.params['name'] || 'Fulan'
-    res.write "Halo, #{name}! Senang bertemu Anda di #{req.user_agent}."
-  end
-
-  get '/hello' do |req, res|
-    name = req.params['name'] || 'Fulan'
-    res.write "Halo, #{name}! Senang bertemu Anda di #{req.user_agent}."
+    res.write "<h1>Selamat Datang di Eks-Cent v#{EksCent::VERSION}!</h1>"
+    res.write "<p>Fitur baru: <strong>URL Mapping</strong> & <strong>Runtime Tracking</strong>.</p>"
+    res.write "<p>Kunjungan: <strong>#{req.session['visits']}</strong></p>"
+    res.write "<hr>"
+    res.write "<ul>"
+    res.write "  <li>Akses API: <a href='/api/status'>/api/status</a></li>"
+    res.write "  <li>Gunakan MethodOverride: <form action='/api/update' method='post' style='display:inline'><input type='hidden' name='_method' value='PUT'><button type='submit'>Kirim PUT via POST</button></form></li>"
+    res.write "  <li>Coba Error: <a href='/error'>/error</a></li>"
+    res.write "</ul>"
   end
 
   get '/error' do |req, res|
-    raise "Waduh! Ada kesalahan yang disengaja di sini."
+    raise "Kesalahan yang disengaja untuk demonstrasi v4.0.0."
   end
 end
 
-run router
+run router_web

data/lib/eks-cent.rb

@@ -1,16 +1,21 @@
-# Eks-Cent: Lightweight Rack-like Communication Interface for Ruby.
+# Eks-Cent: Lightweight Eks-style Communication Interface for Ruby.
 
 require_relative 'eks_cent/version'
 require_relative 'eks_cent/request'
 require_relative 'eks_cent/response'
 require_relative 'eks_cent/builder'
 require_relative 'eks_cent/router'
+require_relative 'eks_cent/url_map'
+require_relative 'eks_cent/cascade'
 require_relative 'eks_cent/mock_request'
 require_relative 'eks_cent/middleware/logger'
 require_relative 'eks_cent/middleware/session'
 require_relative 'eks_cent/middleware/content_security'
 require_relative 'eks_cent/middleware/show_exceptions'
 require_relative 'eks_cent/middleware/static'
+require_relative 'eks_cent/middleware/method_override'
+require_relative 'eks_cent/middleware/runtime'
+require_relative 'eks_cent/middleware/head'
 
 module EksCent
   
@@ -22,7 +27,7 @@ module EksCent
   self.secret_key_base = ENV['EKS_CENT_SECRET_KEY_BASE'] || '1e8a93e80c85b1a6c4b69d9c2e8b2a1a8e1b1d8c1c2e1f2g1h1i1j1k1l1m1n1o'
 
   def self.env
-    ENV['RACK_ENV'] || ENV['EKS_CENT_ENV'] || 'development'
+    ENV['EKS_ENV'] || ENV['RACK_ENV'] || ENV['EKS_CENT_ENV'] || 'development'
   end
 
   def self.production?

data/lib/eks_cent/builder.rb

@@ -14,7 +14,23 @@ module EksCent
       @run = app
     end
 
+    def map(path, &block)
+      @map ||= {}
+      @map[path] = self.class.new(&block).to_app
+    end
+
+    def cascade(*apps)
+      require_relative 'cascade' unless defined?(EksCent::Cascade)
+      @run = Cascade.new(apps)
+    end
+
     def to_app
+      if @map
+        require_relative 'url_map' unless defined?(EksCent::URLMap)
+        @map['/'] = @run if @run
+        @run = URLMap.new(@map)
+      end
+
       app = @run
       raise "Aplikasi tidak ditemukan (run nil)" unless app
       @use.reverse_each { |middleware| app = middleware.call(app) }
@@ -28,7 +44,7 @@ module EksCent
       builder.to_app
     end
 
-    # Helper for Rack-like interface call
+    # Helper for Eks-style interface call
     def call(env)
       to_app.call(env)
     end

data/lib/eks_cent/cascade.rb

@@ -0,0 +1,24 @@
+module EksCent
+  class Cascade
+    def initialize(apps = [])
+      @apps = apps
+    end
+
+    def call(env)
+      last_response = [404, { 'Content-Type' => 'text/plain' }, ["Not Found"]]
+      
+      @apps.each do |app|
+        status, headers, body = app.call(env)
+        
+        # Jika bukan 404, atau header X-Cascade tidak bernilai 'pass', kembalikan respons ini
+        if status.to_i != 404 && headers['X-Cascade'] != 'pass'
+          return [status, headers, body]
+        end
+        
+        last_response = [status, headers, body]
+      end
+      
+      last_response
+    end
+  end
+end

data/lib/eks_cent/middleware/head.rb

@@ -0,0 +1,19 @@
+module EksCent
+  module Middleware
+    class Head
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+
+        if env['REQUEST_METHOD'] == 'HEAD'
+          body = []
+        end
+
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/eks_cent/middleware/method_override.rb

@@ -0,0 +1,38 @@
+module EksCent
+  module Middleware
+    class MethodOverride
+      HTTP_METHODS = %w(GET HEAD POST PUT DELETE PATCH OPTIONS LINK UNLINK)
+      METHOD_OVERRIDE_PARAM_KEY = "_method"
+      HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE"
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["REQUEST_METHOD"] == "POST"
+          method = method_from_env(env)
+          if method && HTTP_METHODS.include?(method.upcase)
+            env["eks_cent.original_method"] = env["REQUEST_METHOD"]
+            env["REQUEST_METHOD"] = method.upcase
+          end
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      def method_from_env(env)
+        # 1. Cek dari header X-HTTP-Method-Override
+        return env[HTTP_METHOD_OVERRIDE_HEADER] if env[HTTP_METHOD_OVERRIDE_HEADER]
+
+        # 2. Cek dari parameter body (_method)
+        req = Request.new(env)
+        return req.params[METHOD_OVERRIDE_PARAM_KEY] if req.params[METHOD_OVERRIDE_PARAM_KEY]
+
+        nil
+      end
+    end
+  end
+end

data/lib/eks_cent/middleware/runtime.rb

@@ -0,0 +1,19 @@
+module EksCent
+  module Middleware
+    class Runtime
+      def initialize(app, header_name = 'X-Runtime')
+        @app = app
+        @header_name = header_name
+      end
+
+      def call(env)
+        start_time = Time.now
+        status, headers, body = @app.call(env)
+        duration = Time.now - start_time
+
+        headers[@header_name] = format("%0.6f", duration)
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/eks_cent/mock_request.rb

@@ -21,10 +21,16 @@ module EksCent
         'PATH_INFO'      => path,
         'QUERY_STRING'   => query || '',
         'HTTP_USER_AGENT' => opts[:user_agent] || 'EksCent-MockRequest',
-        'rack.input'     => StringIO.new(opts[:body] || '')
       }.merge(opts[:env] || {})
       
-      @app.call(env)
+      env['eks.input']   ||= StringIO.new(opts[:body] || '')
+      env['rack.input']  ||= env['eks.input']
+      env['eks.version'] ||= [1, 3]
+      env['rack.version'] ||= env['eks.version']
+      
+      status, headers, body = @app.call(env)
+      require_relative 'mock_response' unless defined?(EksCent::MockResponse)
+      MockResponse.new(status, headers, body)
     end
   end
 end

data/lib/eks_cent/mock_response.rb

@@ -0,0 +1,47 @@
+module EksCent
+  class MockResponse
+    attr_reader :status, :headers, :body
+
+    def initialize(status, headers, body)
+      @status = status.to_i
+      @headers = headers
+      @body = body
+    end
+
+    def body_content
+      @body.is_a?(Array) ? @body.join : @body.to_s
+    end
+
+    def ok?
+      @status == 200
+    end
+
+    def redirect?
+      [301, 302, 303, 307, 308].include?(@status)
+    end
+
+    def client_error?
+      @status >= 400 && @status < 500
+    end
+
+    def server_error?
+      @status >= 500 && @status < 600
+    end
+
+    def not_found?
+      @status == 404
+    end
+
+    def location
+      @headers['Location']
+    end
+
+    def content_type
+      @headers['Content-Type']
+    end
+
+    def to_ary
+      [@status, @headers, @body]
+    end
+  end
+end

data/lib/eks_cent/request.rb

@@ -8,6 +8,19 @@ module EksCent
 
     def initialize(env)
       @env = env
+      # Map standard Rack keys to Eks branding for internal consistency
+      @env['eks.input']   ||= @env['rack.input']
+      @env['rack.input']  ||= @env['eks.input']
+      
+      @env['eks.version'] ||= @env['rack.version'] || [1, 3]
+      @env['rack.version'] ||= @env['eks.version']
+      
+      @env['eks.errors']  ||= @env['rack.errors']
+      @env['rack.errors'] ||= @env['eks.errors']
+      
+      @env['eks.multithread']  ||= @env['rack.multithread'] || false
+      @env['eks.multiprocess'] ||= @env['rack.multiprocess'] || false
+      @env['eks.run_once']     ||= @env['rack.run_once'] || false
     end
 
     def request_method
@@ -56,37 +69,71 @@ module EksCent
     end
 
     def parse_params
-      params = {}
+      require 'rack' unless defined?(Rack)
       
-      # Parse query string
-      params.merge!(CGI.parse(query_string)) if query_string != ''
+      # Terapkan batasan global Eks/Rack jika ada di ENV
+      setup_eks_limits
+
+      # Gunakan Rack::Request untuk menangani parsing parameter standar (GET/POST/Multipart)
+      rack_req = Rack::Request.new(@env)
+      params = rack_req.params.dup
 
-      # Parse router params if any
+      # Gabungkan dengan parameter dari router (misal: /hello/:name)
       if @env['eks_cent.router_params']
         params.merge!(@env['eks_cent.router_params'])
       end
 
-      # Parse body based on content type
-      if @env['rack.input']
-        body = @env['rack.input'].read
-        @env['rack.input'].rewind if @env['rack.input'].respond_to?(:rewind)
-        
-        if body && !body.empty?
-          if @env['CONTENT_TYPE'] == 'application/json'
-            begin
-              params.merge!(JSON.parse(body))
-            rescue JSON::ParserError
-              # Silently ignore invalid JSON or we could log it
+      # Tambahkan parsing JSON manual karena Rack::Request tidak melakukannya secara otomatis
+      if @env['CONTENT_TYPE'] == 'application/json' && @env['eks.input']
+        begin
+          body = @env['eks.input'].read
+          @env['eks.input'].rewind if @env['eks.input'].respond_to?(:rewind)
+          
+          if body && !body.empty?
+            json_params = JSON.parse(body)
+            if json_params.is_a?(Hash)
+              # Batasi jumlah parameter JSON jika EKS/RACK_QUERY_PARSER_PARAMS_LIMIT diatur
+              limit = (ENV['EKS_QUERY_PARSER_PARAMS_LIMIT'] || ENV['RACK_QUERY_PARSER_PARAMS_LIMIT'])&.to_i || 1000
+              if json_params.size > limit
+                raise "Too many parameters (JSON)"
+              end
+              params.merge!(json_params)
             end
-          else
-            # Default to form-urlencoded if it's a POST/PUT/PATCH
-            params.merge!(CGI.parse(body)) if post? || @env['REQUEST_METHOD'] == 'PUT' || @env['REQUEST_METHOD'] == 'PATCH'
           end
+        rescue JSON::ParserError
+          # Abaikan error parsing JSON
         end
       end
 
-      # Flatten single values
+      # Pastikan nilai parameter diratakan (flatten) jika berupa array berukuran 1
+      # Catatan: Rack::Request mungkin sudah melakukannya untuk form data standar, 
+      # tapi kita pastikan konsistensi di sini.
       params.transform_values { |v| v.is_a?(Array) && v.size == 1 ? v.first : v }
     end
+    def setup_eks_limits
+      return if @eks_limits_setup
+      
+      parser = Rack::Utils.default_query_parser rescue nil
+      return unless parser
+
+      params_limit = ENV['EKS_QUERY_PARSER_PARAMS_LIMIT'] || ENV['RACK_QUERY_PARSER_PARAMS_LIMIT']
+      if params_limit && parser.respond_to?(:params_limit=)
+        parser.params_limit = params_limit.to_i
+      end
+
+      bytesize_limit = ENV['EKS_QUERY_PARSER_BYTESIZE_LIMIT'] || ENV['RACK_QUERY_PARSER_BYTESIZE_LIMIT']
+      if bytesize_limit && parser.respond_to?(:bytesize_limit=)
+        parser.bytesize_limit = bytesize_limit.to_i
+      end
+      
+      multipart_limit = ENV['EKS_MULTIPART_TOTAL_PART_LIMIT'] || ENV['RACK_MULTIPART_TOTAL_PART_LIMIT']
+      if multipart_limit
+        if Rack::Utils.respond_to?(:multipart_total_part_limit=)
+          Rack::Utils.multipart_total_part_limit = multipart_limit.to_i
+        end
+      end
+      
+      @eks_limits_setup = true
+    end
   end
 end

data/lib/eks_cent/response.rb

@@ -3,18 +3,27 @@ require 'time'
 
 module EksCent
   class Response
-    attr_accessor :status, :headers, :body
+    attr_accessor :status, :headers, :body, :request
 
-    def initialize(body = [], status = 200, headers = {})
+    def initialize(body = [], status = 200, headers = {}, request: nil)
       @status = status
       @headers = { 'Content-Type' => 'text/html' }.merge(headers)
       @body = body.is_a?(String) ? [body] : body
+      @request = request
     end
 
     def write(str)
       @body << str
     end
 
+    def set_header(key, value)
+      @headers[key] = value
+    end
+
+    def content_type=(type)
+      @headers['Content-Type'] = type
+    end
+
     def redirect(target, status = 302)
       @status = status
       @headers['Location'] = target
@@ -25,7 +34,7 @@ module EksCent
       @cookies[name] = options.merge(value: value)
     end
 
-    def render(template_name, locals = {})
+    def render(template_name, layout: true, **locals)
       require 'erb'
       template_path = File.join('views', "#{template_name}.erb")
       unless File.file?(template_path)
@@ -37,12 +46,34 @@ module EksCent
       # Gunakan context khusus agar helper h (escape HTML) tersedia
       context = Object.new
       context.extend(ERB::Util)
+      
+      # Suntikkan objek internal
+      context.instance_variable_set("@req", @request) if @request
+      context.instance_variable_set("@res", self)
+      
+      # Suntikkan locals
       locals.each { |k, v| context.instance_variable_set("@#{k}", v) }
       
-      # Definisikan metode helper h secara eksplisit jika perlu
-      def context.h(s); html_escape(s); end
+      # Definisikan metode helper h secara eksplisit untuk keamanan
+      def context.h(s); CGI.escapeHTML(s.to_s); end
+
+      # Render template utama
+      result = ERB.new(template_content).result(context.instance_eval { binding })
+
+      # Dukungan Layout (default mencari views/layout.erb)
+      if layout
+        layout_name = layout == true ? 'layout' : layout.to_s
+        layout_path = File.join('views', "#{layout_name}.erb")
+        
+        if File.file?(layout_path)
+          context.instance_variable_set("@content", result)
+          layout_content = File.read(layout_path)
+          result = ERB.new(layout_content).result(context.instance_eval { binding })
+        end
+      end
 
-      @body << ERB.new(template_content).result(context.instance_eval { binding })
+      @headers['Content-Type'] ||= 'text/html'
+      @body << result
     end
 
     def finish

data/lib/eks_cent/router.rb

@@ -10,9 +10,25 @@ module EksCent
       }
       @prefix = ''
       @current_middlewares = []
+      @not_found_block = nil
+      @error_block = nil
       instance_eval(&block) if block_given?
     end
 
+    def not_found(&block)
+      @not_found_block = block
+    end
+
+    def error(&block)
+      @error_block = block
+    end
+
+    def halt(res, status = nil, body = nil)
+      res.status = status if status
+      res.write(body) if body
+      throw(:halt)
+    end
+
     def get(path, &block)    add_route('GET', path, &block) end
     def post(path, &block)   add_route('POST', path, &block) end
     def put(path, &block)    add_route('PUT', path, &block) end
@@ -52,8 +68,19 @@ module EksCent
         # Wrapped application with route-specific middlewares
         app = proc do |e| 
           req_i = Request.new(e)
-          res_i = Response.new
-          instance_exec(req_i, res_i, &route[:block])
+          res_i = Response.new(request: req_i)
+          begin
+            catch(:halt) do
+              instance_exec(req_i, res_i, &route[:block])
+            end
+          rescue => err
+            if @error_block
+              res_i.status = 500
+              instance_exec(err, req_i, res_i, &@error_block)
+            else
+              raise err
+            end
+          end
           res_i.finish
         end
         route[:middlewares].reverse_each { |m| app = m.new(app) }
@@ -61,12 +88,28 @@ module EksCent
         _status, headers, body = app.call(env)
         [_status, headers, body]
       else
-        [404, { 'Content-Type' => 'text/plain' }, ["Not Found"]]
+        handle_not_found(env)
       end
     end
 
     private
 
+    def handle_not_found(env)
+      req = Request.new(env)
+      res = Response.new(request: req)
+      res.status = 404
+
+      if @not_found_block
+        instance_exec(req, res, &@not_found_block)
+        res.finish
+      elsif File.exist?(File.join('views', '404.erb'))
+        res.render '404'
+        res.finish
+      else
+        [404, { 'Content-Type' => 'text/plain' }, ["Not Found"]]
+      end
+    end
+
     def add_route(method, path, &block)
       keys = []
       full_path = "#{@prefix}#{path}".gsub('//', '/')

data/lib/eks_cent/url_map.rb

@@ -0,0 +1,29 @@
+module EksCent
+  class URLMap
+    def initialize(map = {})
+      @mapping = map.map do |path, app|
+        [path.chomp('/'), app]
+      end.sort_by { |path, _| -path.length } # Sort by longest path first
+    end
+
+    def call(env)
+      path_info = env['PATH_INFO'] || ''
+      script_name = env['SCRIPT_NAME'] || ''
+
+      @mapping.each do |path, app|
+        next unless path_info.start_with?(path)
+        next unless path_info == path || path_info[path.length] == '/'
+
+        # Matched path: shift script_name and path_info
+        new_env = env.dup
+        new_env['SCRIPT_NAME'] = script_name + path
+        new_env['PATH_INFO'] = path_info[path.length..-1].to_s
+        new_env['PATH_INFO'] = '/' if new_env['PATH_INFO'].empty?
+
+        return app.call(new_env)
+      end
+
+      [404, { 'Content-Type' => 'text/plain', 'X-Cascade' => 'pass' }, ["Not Found (URLMap)"]]
+    end
+  end
+end

data/lib/eks_cent/version.rb

@@ -1,3 +1,3 @@
 module EksCent
-  VERSION = '3.0.0'
+  VERSION = '4.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eks-cent
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - IshikawaUta
@@ -27,16 +27,16 @@ dependencies:
   name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 description: Eks-Cent adalah framework web minimalis yang menyediakan sistem routing
   canggih, manajemen session HMAC, dan proteksi keamanan bawaan menggunakan Eksa-Server
   sebagai engine utama.
@@ -47,29 +47,37 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - bin/ekscentup
 - config.eks
+- images/logo.webp
 - lib/eks-cent.rb
 - lib/eks_cent/builder.rb
+- lib/eks_cent/cascade.rb
 - lib/eks_cent/middleware/content_security.rb
+- lib/eks_cent/middleware/head.rb
 - lib/eks_cent/middleware/logger.rb
+- lib/eks_cent/middleware/method_override.rb
+- lib/eks_cent/middleware/runtime.rb
 - lib/eks_cent/middleware/session.rb
 - lib/eks_cent/middleware/show_exceptions.rb
 - lib/eks_cent/middleware/static.rb
 - lib/eks_cent/mock_request.rb
+- lib/eks_cent/mock_response.rb
 - lib/eks_cent/request.rb
 - lib/eks_cent/response.rb
 - lib/eks_cent/router.rb
+- lib/eks_cent/url_map.rb
 - lib/eks_cent/version.rb
 homepage: https://github.com/IshikawaUta/eks-cent
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/IshikawaUta/eks-cent
   source_code_uri: https://github.com/IshikawaUta/eks-cent
+  changelog_uri: https://github.com/IshikawaUta/eks-cent/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -86,5 +94,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
-summary: Framework web Ruby ringan, aman, dan siap produksi berbasis Rack.
+summary: Framework web Ruby ringan, aman, dan siap produksi berbasis Eks Interface.
 test_files: []