stipa 0.1.0

data/lib/stipa/generators/vue.rb

@@ -0,0 +1,442 @@
+require_relative 'base'
+
+module Stipa
+  module Generators
+    class Vue < Base
+      private
+
+      def template_name = 'vue'
+
+      def dirs
+        %w[
+          src/config
+          src/controllers
+          src/models
+          src/views/layouts
+          src/views/home
+          src/components
+          public/components
+        ]
+      end
+
+      def post_generate
+        copy_asset 'stipa-vue.js',   from: GEM_JS
+        copy_asset 'logo.png',     from: GEM_MEDIA
+        copy_asset 'favicon.ico',  from: GEM_MEDIA
+      end
+
+      def copy_asset(file, from:)
+        src = File.join(from, file)
+        if File.exist?(src)
+          FileUtils.cp(src, File.join(target, "public/#{file}"))
+          say "  create  public/#{file}"
+        else
+          say "  warn    #{file} not found — copy it manually to public/"
+        end
+      end
+
+      def done_message
+        <<~DONE
+
+          Done! Next steps:
+            cd #{name}
+            bundle install
+            npm install
+            npm run build       # compile Vue components
+            bundle exec ruby server.rb
+        DONE
+      end
+
+      def files
+        {
+          'Gemfile'                                => t_gemfile,
+          'package.json'                           => t_package_json,
+          'rollup.config.js'                       => t_rollup_config,
+          'tsconfig.json'                          => t_tsconfig,
+          'server.rb'                                      => t_server,
+          'src/config/routes.rb'                         => t_routes(
+            extra_requires: ['../controllers/home_controller', '../controllers/health_controller'],
+            extra_routes:   ["get '/', to: 'home#index'", "get '/api/health', to: 'health#show'"],
+            method_override: true,
+          ),
+          'src/controllers/application_controller.rb'   => t_application_controller,
+          'src/controllers/home_controller.rb'           => t_home_controller,
+          'src/controllers/health_controller.rb'         => t_health_controller,
+          'src/views/layouts/application.html.erb'      => t_layout,
+          'src/views/home/index.html.erb'                => t_home_index,
+          'public/app.css'                               => t_app_css,
+          'src/components/RequestCard.vue'               => t_request_card_vue,
+        }
+      end
+
+      def t_package_json
+        JSON.pretty_generate(
+          name: name,
+          private: true,
+          type: 'module',
+          scripts: {
+            build: 'rollup -c',
+            watch: 'rollup -c --watch',
+            dev: 'concurrently "bundle exec ruby server.rb" "rollup -c --watch"',
+          },
+          devDependencies: {
+            'concurrently'              => '^8.0.0',
+            'rollup'                    => '^4.0.0',
+            'rollup-plugin-vue'         => '^6.0.0',
+            '@rollup/plugin-typescript' => '^11.0.0',
+            '@vue/compiler-sfc'         => '^3.4.0',
+            'typescript'                => '^5.0.0',
+            'vue'                       => '^3.4.0',
+          },
+        ) + "\n"
+      end
+
+      def t_rollup_config
+        <<~JS
+          import vue from 'rollup-plugin-vue'
+          import typescript from '@rollup/plugin-typescript'
+          import { readdirSync } from 'fs'
+
+          const src = './src/components'
+          const out = './public/components'
+
+          const inputs = readdirSync(src).filter(f => f.endsWith('.vue') || f.endsWith('.ts'))
+
+          export default inputs.map(file => {
+            const name = file.replace(/\\.(vue|ts)$/, '')
+            const isTs = file.endsWith('.ts')
+            return {
+              input: `${src}/${file}`,
+              output: {
+                file: `${out}/${name}.js`,
+                format: 'iife',
+                name,
+                globals: { vue: 'Vue' },
+              },
+              external: ['vue'],
+              // rollup-plugin-vue handles <script lang="ts"> internally;
+              // @rollup/plugin-typescript is only needed for plain .ts files.
+              plugins: [vue(), ...(isTs ? [typescript({ tsconfig: './tsconfig.json' })] : [])],
+            }
+          })
+        JS
+      end
+
+      def t_tsconfig
+        JSON.pretty_generate(
+          compilerOptions: {
+            target:           'ESNext',
+            module:           'ESNext',
+            moduleResolution: 'bundler',
+            strict:           true,
+            skipLibCheck:     true,
+          },
+          include: ['src/**/*'],
+        ) + "\n"
+      end
+
+      def t_server
+        <<~RUBY
+          require 'stipa'
+          require_relative 'src/config/routes'
+
+          APP_DIR = __dir__
+
+          app = Stipa::App.new(
+            views:  "\#{APP_DIR}/src/views",
+            public: "\#{APP_DIR}/public",
+          )
+
+          app.use Stipa::Middleware::RequestId
+          app.use Stipa::Middleware::Timing
+
+          Routes.draw(app)
+
+          app.get '/api/health' do |_req, res|
+            res.json({ status: 'ok', framework: 'Stipa', version: Stipa::VERSION, ts: Time.now.utc.iso8601 })
+          end
+
+          app.start(host: '0.0.0.0', port: 3710)
+        RUBY
+      end
+
+      def t_application_controller
+        <<~RUBY
+          require 'uri'
+
+          class ApplicationController
+            attr_reader :req, :res
+
+            def initialize(req, res)
+              @req    = req
+              @res    = res
+              @params = nil
+            end
+
+            private
+
+            def render(template, locals: {}, layout: :default)
+              res.render(template, locals: locals, layout: layout)
+            end
+
+            def redirect_to(path, status: 302)
+              res.status      = status
+              res['Location'] = path
+              res.body        = ''
+            end
+
+            def not_found!(message = 'Not Found')
+              res.status = 404
+              res.body   = message
+              throw :halt
+            end
+
+            def params
+              @params ||= begin
+                p = req.params.dup
+
+                req.query_string.split('&').each do |pair|
+                  next if pair.empty?
+                  k, v = pair.split('=', 2)
+                  p[k.to_sym] = URI.decode_www_form_component(v.to_s)
+                end
+
+                if req['content-type']&.include?('application/x-www-form-urlencoded')
+                  req.body.split('&').each do |pair|
+                    next if pair.empty?
+                    k, v = pair.split('=', 2)
+                    p[k.to_sym] = URI.decode_www_form_component(v.to_s)
+                  end
+                end
+
+                p
+              end
+            end
+
+            def flash_notice = params[:flash]
+          end
+        RUBY
+      end
+
+      def t_home_controller
+        <<~RUBY
+          require_relative 'application_controller'
+
+          class HomeController < ApplicationController
+            def index
+              render('home/index')
+            end
+          end
+        RUBY
+      end
+
+      def t_health_controller
+        <<~RUBY
+          require 'time'
+          require_relative 'application_controller'
+
+          class HealthController < ApplicationController
+            def show
+              res.json({
+                status:  'ok',
+                method:  req.method,
+                path:    req.path,
+                host:    req['host'] || 'localhost:3710',
+                version: Stipa::VERSION,
+                ts:      Time.now.utc.iso8601,
+              })
+            end
+          end
+        RUBY
+      end
+
+      def t_layout
+        <<~ERB
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title><%= content_for(:title) || '#{app_title}' %></title>
+            <link rel="icon" href="/favicon.ico">
+            <%= stylesheet_tag '/app.css' %>
+
+            <%# Vue 3 global build — sets window.Vue %>
+            <script src="https://unpkg.com/vue@3/dist/vue.global.prod.js"></script>
+
+            <%# Stipa Vue bootstrapper — sets window.StipaVue, auto-mounts on DOMContentLoaded %>
+            <%= stipa_vue_bootstrap %>
+
+            <%# Compiled Vue components — add one block per component %>
+            <script src="/components/RequestCard.js"></script>
+            <script>
+              window.StipaVue.register('RequestCard', window.RequestCard)
+            </script>
+
+            <%# Measure time from first byte to DOMContentLoaded %>
+            <script>const _t0 = performance.now()</script>
+          </head>
+          <body>
+            <%= content %>
+          </body>
+          </html>
+        ERB
+      end
+
+      def t_home_index
+        <<~ERB
+          <div class="circle-wrap">
+            <div class="hoop"></div>
+            <img src="/logo.png" alt="Stipa" class="logo">
+            <div class="circle-text">
+              <h1>STĪPA</h1>
+              <div class="tagline">Lightweight. Ruby. Bare HTTP.</div>
+            </div>
+          </div>
+          <div class="container">
+            <div data-vue-component="RequestCard"></div>
+
+            <div class="stats">
+              <p>Stipa <%= h Stipa::VERSION %> | stdlib only | no gems</p>
+            </div>
+          </div>
+        ERB
+      end
+
+      def t_app_css
+        <<~CSS
+          :root { --red: #cc0000; --black: #1a1a1a; --white: #f4f4f4; }
+
+          body {
+            background: var(--white);
+            color: var(--black);
+            font-family: 'Input Mono', 'Menlo', monospace;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            margin: 0;
+            gap: 1.5rem;
+            padding: 2rem 1rem;
+            box-sizing: border-box;
+          }
+
+          .circle-wrap {
+            position: relative;
+            width: 300px;
+            height: 300px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            flex-shrink: 0;
+          }
+
+          .container { text-align: center; }
+
+          .circle-text {
+            position: relative;
+            z-index: 2;
+            text-align: center;
+          }
+
+          .logo {
+            position: absolute;
+            width: 220px;
+            height: 220px;
+            object-fit: contain;
+            opacity: 0.1;
+            z-index: 1;
+          }
+
+          .hoop {
+            position: absolute;
+            inset: 0;
+            border: 2px solid var(--red);
+            border-radius: 50%;
+            animation: rotate 10s linear infinite;
+            opacity: 0.1;
+          }
+
+          @keyframes rotate {
+            from { transform: rotate(0deg) scale(1); }
+            to   { transform: rotate(360deg) scale(1.1); }
+          }
+
+          h1 { font-size: 3rem; letter-spacing: -2px; margin: 0; }
+
+          .tagline { color: var(--red); font-weight: bold; }
+
+          .code-box {
+            background: #eee;
+            padding: 20px;
+            border-radius: 4px;
+            text-align: left;
+            display: inline-block;
+          }
+
+          .stats {
+            font-size: 0.8rem;
+            border-top: 1px solid #ddd;
+            padding-top: 1rem;
+            color: #666;
+          }
+
+          code { font-family: 'Input Mono', 'Menlo', monospace; }
+          .red  { color: #d33; }
+
+          /* ── General pages (non-splash) ── */
+          .page {
+            max-width: 860px;
+            margin: 0 auto;
+            padding: 3rem 1.5rem 6rem;
+          }
+        CSS
+      end
+
+
+
+      def t_request_card_vue
+        <<~VUE
+          <template>
+            <div class="code-box">
+              <code class="red"># Request Processed in {{ renderTime }}ms</code><br>
+              <code>{{ line1 }}</code><br>
+              <code>{{ line2 }}</code><br>
+              <code>{{ line3 }}</code>
+            </div>
+          </template>
+
+          <script lang="ts">
+          import { defineComponent, ref, onMounted } from 'vue'
+
+          export default defineComponent({
+            name: 'RequestCard',
+            setup() {
+              const renderTime = ref('…')
+              const line1 = ref('…')
+              const line2 = ref('…')
+              const line3 = ref('…')
+
+              onMounted(async () => {
+                renderTime.value = (performance.now() - (window._t0 || 0)).toFixed(1)
+
+                try {
+                  const d = await fetch('/api/health').then(r => r.json())
+                  line1.value = d.method + ' ' + d.path + ' HTTP/1.1'
+                  line2.value = 'Host: ' + d.host
+                  line3.value = 'Status: 200 OK'
+                } catch {
+                  line1.value = 'Failed to load health data'
+                }
+              })
+
+              return { renderTime, line1, line2, line3 }
+            },
+          })
+          </script>
+        VUE
+      end
+    end
+  end
+end

data/lib/stipa/logger.rb

@@ -0,0 +1,65 @@
+require 'monitor'
+
+module Stipa
+  # Structured, leveled logger that writes one logfmt line per event.
+  #
+  # Format (parseable by Splunk, Datadog, Loki, grep):
+  #   time=2026-03-18T12:00:00.123Z level=INFO req_id=a1b2c3d4 method=GET
+  #   path=/users status=200 bytes_in=0 bytes_out=412
+  #
+  # Thread-safe via Monitor (reentrant mutex — safe when a log call
+  # triggers another log call from a rescue block in the same thread).
+  class Logger
+    LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
+
+    def initialize(output: $stdout, level: :info)
+      @output = output
+      @level  = LEVELS.fetch(level, 1)
+      @lock   = Monitor.new
+    end
+
+    # Log a completed request/response cycle. Called by Connection.
+    def info(req: nil, res: nil, bytes_in: 0, bytes_out: 0, **extra)
+      return if @level > LEVELS[:info]
+      fields = {
+        time:      utc_now,
+        level:     'INFO',
+        req_id:    req&.id    || '-',
+        method:    req&.method || '-',
+        path:      req&.path   || '-',
+        status:    res&.status || '-',
+        bytes_in:  bytes_in,
+        bytes_out: bytes_out,
+      }.merge(extra)
+      write(logfmt(fields))
+    end
+
+    def warn(msg, **fields);  log(:warn,  msg, **fields); end
+    def error(msg, **fields); log(:error, msg, **fields); end
+    def debug(msg, **fields); log(:debug, msg, **fields); end
+
+    private
+
+    def log(level, msg, **fields)
+      return if @level > LEVELS[level]
+      write(logfmt({ time: utc_now, level: level.to_s.upcase, msg: msg }.merge(fields)))
+    end
+
+    def write(line)
+      @lock.synchronize { @output.puts(line) }
+    end
+
+    # Encode as logfmt: key=value pairs, quoting values with special chars.
+    def logfmt(fields)
+      fields.map do |k, v|
+        v_s = v.to_s
+        v_s = %("#{v_s.gsub('"', '\\"')}") if v_s.match?(/[ ="\\]/)
+        "#{k}=#{v_s}"
+      end.join(' ')
+    end
+
+    def utc_now
+      Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%3NZ')
+    end
+  end
+end

data/lib/stipa/middleware.rb

@@ -0,0 +1,127 @@
+require 'securerandom'
+
+module Stipa
+  # A minimal middleware stack inspired by Rack.
+  #
+  # Middleware signature:  call(req, res) -> res
+  #
+  # The stack is compiled ONCE at server start into a chain of nested
+  # closures. Per-request cost is zero stack traversal — it's just
+  # nested method calls. The first `use`-d middleware is outermost
+  # (runs first on the way in, last on the way out).
+  #
+  # Example:
+  #   app.use Stipa::Middleware::RequestId
+  #   app.use Stipa::Middleware::Timing
+  #   app.use Stipa::Middleware::Cors, origins: ['https://example.com']
+  class MiddlewareStack
+    def initialize
+      @layers = []
+    end
+
+    def use(middleware, **options)
+      @layers << [middleware, options]
+      self
+    end
+
+    # Insert a middleware at the front of the stack (runs before all others).
+    # Used internally by App to prepend Static before user middleware.
+    def prepend(middleware, **options)
+      @layers.unshift([middleware, options])
+      self
+    end
+
+    # Compile the stack around `app` (the router callable).
+    # Returns a single callable: call(req, res) -> res
+    def build(app)
+      # Reverse so first-added middleware ends up outermost
+      @layers.reverse_each do |klass_or_proc, opts|
+        inner = app
+        app = if klass_or_proc.respond_to?(:new)
+                klass_or_proc.new(inner, **opts)
+              else
+                # Plain lambda/proc: wrap so it receives next_app context
+                ->(req, res) { klass_or_proc.call(req, res, inner) }
+              end
+      end
+      app
+    end
+
+    def empty?; @layers.empty?; end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Built-in middleware
+  # ---------------------------------------------------------------------------
+
+  module Middleware
+    # Propagates an upstream X-Request-Id header or mints a new one.
+    # Runs before the router so req.id is always set when handlers execute.
+    #
+    # With a load balancer / API gateway that injects X-Request-Id, distributed
+    # traces stay correlated across services automatically.
+    class RequestId
+      def initialize(next_app, header: 'X-Request-Id')
+        @next_app = next_app
+        @header   = header
+      end
+
+      def call(req, res)
+        # Header lookup is lowercase in Request; header name for response is as-is
+        req.id = req[@header.downcase] || SecureRandom.hex(8)
+        res.set_header(@header, req.id)
+        @next_app.call(req, res)
+      end
+    end
+
+    # Records wall-clock time and appends X-Response-Time to the response.
+    # Uses CLOCK_MONOTONIC (not Time.now) so system clock adjustments don't
+    # produce negative or inflated durations.
+    class Timing
+      def initialize(next_app)
+        @next_app = next_app
+      end
+
+      def call(req, res)
+        t0     = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = @next_app.call(req, res)
+        ms     = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
+        result.set_header('X-Response-Time', "#{ms}ms")
+        result
+      end
+    end
+
+    # Simple CORS headers. Handles OPTIONS preflight automatically.
+    # Pass origins: ['*'] to allow all, or a specific list for allowlisting.
+    class Cors
+      def initialize(next_app, origins: ['*'],
+                     methods: %w[GET POST PUT PATCH DELETE OPTIONS])
+        @next_app = next_app
+        @origins  = Array(origins)
+        @methods  = methods.join(', ')
+      end
+
+      def call(req, res)
+        origin  = req['origin'] || '*'
+        allowed = @origins.include?('*') || @origins.include?(origin)
+
+        if allowed
+          res.set_header('Access-Control-Allow-Origin',  origin)
+          res.set_header('Access-Control-Allow-Methods', @methods)
+          res.set_header('Access-Control-Allow-Headers',
+                         'Content-Type, Authorization, X-Request-Id')
+          # Vary tells caches that the response differs by Origin
+          res.set_header('Vary', 'Origin')
+        end
+
+        # OPTIONS preflight: respond immediately without hitting the router
+        if req.method == 'OPTIONS'
+          res.status = 204
+          return res
+        end
+
+        @next_app.call(req, res)
+      end
+    end
+  end
+end