tina4ruby 3.13.35 → 3.13.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cdb8976e4e87658d1655be468112a986b32817f18f5415d96c8744d3f2b179c
-  data.tar.gz: d2f3c50d3b646e062d38c088090b0919c347ecec1b130edcd661c0921b743846
+  metadata.gz: b75f9ed6546e671904c26e7dc9bb1f29fc83a62a63a7488d05540e12c535f32f
+  data.tar.gz: f33418ea68192ed529eb2f0b7953e2762ca5eface4c8b4b368b8a93c57344981
 SHA512:
-  metadata.gz: 37f1743a3ef8f314baf055c84bf7696174b5977af5b2d9e87b5ceb5e93ed2d6a4870d4dcf2ca7e75f3e4e4734368274e84c4160c94199c7da59d57f5f5432194
-  data.tar.gz: addb86d53bfc8d864dd93bc3dc52015c21e133590109ae91d262f082ecf55368acada387097b2e9340fddc5ae1443ba0bb5dd085492d6e2b2e5f90a81eb582cb
+  metadata.gz: 413ecc40fcc877a0ea0cfbdca95ef5a3b5da3b3f24035787a9619ecc385e4735e5532eea10c34cbe316727f4544865adea62fcf0233804019815c52f699674fd
+  data.tar.gz: 84c7bd505379a49527cb75eead709eb8155225a90406ee5691afdfc53127129e013b5c3ede53c7cb35df44dcbdeb3467fdaa91adf6881f159ffe3912476ec65e

data/lib/tina4/dev_admin.rb

@@ -392,12 +392,30 @@ module Tina4
           reload_type = body["type"] || "reload"
           Tina4::Log.info("External reload trigger: #{reload_type}#{@reload_file.empty? ? '' : " (#{@reload_file})"}")
           # Re-discover so files dropped into src/routes/ register without
-          # a server restart. Idempotent — already-loaded files are skipped.
+          # a server restart. Idempotent — already-loaded files are skipped,
+          # changed files are re-loaded (mtime-tracked).
           begin
             Tina4::Router.rescan_routes!
           rescue StandardError => e
             Tina4::Log.error("Re-discover on reload failed: #{e.message}")
           end
+          # WebSocket-primary reload: push an instant message to every browser
+          # connected on /__dev_reload. The toolbar client (and the dev-admin
+          # dashboard) act on this immediately — the mtime poll above is only a
+          # fallback for when the socket is down. CSS changes swap stylesheets;
+          # everything else triggers a full page reload. We normalise the wire
+          # `type` to "css"/"reload" (the clients only react to css/reload/change)
+          # but still echo the caller's original type in the HTTP response.
+          # Wrapped so a broadcast failure — or zero connected clients — never
+          # 500s the reload endpoint.
+          begin
+            ws_type = reload_type == "css" ? "css" : "reload"
+            Tina4::DevReload.broadcast(
+              JSON.generate({ type: ws_type, file: @reload_file, mtime: @reload_mtime })
+            )
+          rescue StandardError => e
+            Tina4::Log.error("Dev-reload WebSocket broadcast failed: #{e.message}")
+          end
           json_response({ ok: true, type: reload_type })
         when ["GET", "/__dev/api/status"]
           json_response(status_payload)
@@ -1258,24 +1276,146 @@ module Tina4
         resolved
       end
 
+      # Noise dirs + hidden dot-entries are hidden from the file browser,
+      # except the env files — verbatim parity with PHP/Python dev-admin.
+      DEV_FILES_IGNORED = %w[__pycache__ node_modules vendor .git venv .venv dist target .tina4].freeze
+
+      def dev_files_hidden?(name)
+        return true if DEV_FILES_IGNORED.include?(name)
+        name.start_with?(".") && name != ".env" && name != ".env.example"
+      end
+
+      # Same 4-status mapping Python/PHP use for a porcelain code.
+      def dev_git_status_label(code)
+        return "untracked" if code == "??"
+        return "modified" if code.include?("M")
+        return "added" if code.include?("A")
+        return "deleted" if code.include?("D")
+        "clean"
+      end
+
+      # Branch + porcelain status map for the file browser (mirrors PHP/Python
+      # dev-admin). Paths git reports are relative to the repo root (always
+      # forward-slash); the project root may sit inside a larger repo, so the
+      # toplevel is returned too for rebasing. Empty on any error / no git.
+      def dev_git_info(root)
+        require "shellwords" unless defined?(Shellwords)
+        esc = Shellwords.escape(root)
+        inside = `cd #{esc} && git rev-parse --is-inside-work-tree 2>/dev/null`.strip
+        return { branch: "", git_root: nil, status: {} } unless inside == "true"
+
+        branch = `cd #{esc} && git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+        top = `cd #{esc} && git rev-parse --show-toplevel 2>/dev/null`.strip
+        git_root = top.empty? ? nil : top.tr("\\", "/").sub(%r{/+\z}, "")
+
+        status = {}
+        `cd #{esc} && git status --porcelain -uall 2>/dev/null`.each_line do |line|
+          line = line.chomp
+          next if line.length < 4
+          code = line[0, 2].strip
+          path = line[3..].to_s.strip
+          if (idx = path.index(" -> ")) # rename/copy — keep destination
+            path = path[(idx + 4)..]
+          end
+          next if path.nil? || path.empty?
+          status[path] = code
+        end
+        { branch: branch, git_root: git_root, status: status }
+      rescue StandardError
+        { branch: "", git_root: nil, status: {} }
+      end
+
       def files_list(env)
+        # Response shape matches tina4-python / tina4-php 1:1 so the dev-admin
+        # SPA works against every framework: each entry carries `is_dir`,
+        # `has_children`, `git_status` and `size`; the payload carries `branch`.
         rel = query_param(env, "path") || "."
-        begin
-          target = safe_project_path(rel)
-          return { error: "Not found" } unless File.exist?(target)
-          return { error: "Not a directory" } unless File.directory?(target)
-          entries = Dir.children(target).sort.map do |name|
-            full = File.join(target, name)
-            {
-              name: name,
-              type: File.directory?(full) ? "dir" : "file",
-              size: File.file?(full) ? File.size(full) : 0
-            }
+        root = File.expand_path(Dir.pwd)
+        git = dev_git_info(root)
+
+        # Missing/invalid paths return an empty-but-valid shape (not an error
+        # body): the SPA restores expanded-folder state from localStorage and
+        # non-existent folders would otherwise spam the console.
+        target = begin
+          safe_project_path(rel)
+        rescue StandardError
+          nil
+        end
+        unless target && File.directory?(target)
+          return { path: rel, branch: git[:branch], entries: [], error: "not a directory" }
+        end
+
+        root_fwd = root.tr("\\", "/")
+        cwd_in_git = ""
+        if git[:git_root] && git[:git_root] != root_fwd && root_fwd.start_with?(git[:git_root])
+          cwd_in_git = root_fwd[git[:git_root].length..].to_s.sub(%r{\A/+}, "")
+          cwd_in_git += "/" unless cwd_in_git.empty?
+        end
+
+        entries = Dir.children(target).sort.filter_map do |name|
+          next if dev_files_hidden?(name)
+          full = File.join(target, name)
+          entry_rel = full[root.length..].to_s.sub(%r{\A/+}, "").tr("\\", "/")
+          is_dir = File.directory?(full)
+
+          # git status for this entry (same mapping PHP/Python use)
+          git_path = cwd_in_git + entry_rel
+          label = "clean"
+          if (code = git[:status][git_path])
+            label = dev_git_status_label(code)
+          elsif is_dir
+            prefix = "#{git_path}/" # propagate dirty status from any child
+            hit = git[:status].find { |gf, _| gf.start_with?(prefix) }
+            label = (hit && hit[1] == "??") ? "untracked" : "modified" if hit
           end
-          { path: rel, entries: entries, count: entries.size }
-        rescue => e
-          { error: e.message }
+
+          # has_children: does the dir contain anything visible?
+          has_children = nil
+          if is_dir
+            has_children = begin
+              Dir.children(full).any? { |c| !dev_files_hidden?(c) }
+            rescue StandardError
+              false
+            end
+          end
+
+          {
+            name: name,
+            path: entry_rel,
+            is_dir: is_dir,
+            has_children: has_children,
+            git_status: label,
+            size: is_dir ? nil : (File.size(full) rescue 0)
+          }
         end
+
+        { path: rel, branch: git[:branch], entries: entries, count: entries.size }
+      end
+
+      # Map a relative path to a CodeMirror language string. IDENTICAL in
+      # coverage to the Python master (tina4_python/dev_admin lang_map). The
+      # dev-admin SPA reads the "language" field to pick its grammar.
+      def dev_admin_language(rel)
+        base = File.basename(rel.to_s).downcase
+        return "dockerfile" if %w[dockerfile dockerfile.dev dockerfile.prod].include?(base)
+        return "env" if base == ".env" || base == ".env.example"
+
+        ext_map = {
+          ".py" => "python", ".php" => "php", ".rb" => "ruby",
+          ".ts" => "typescript", ".js" => "javascript", ".jsx" => "javascript",
+          ".tsx" => "typescript", ".json" => "json", ".html" => "html",
+          ".twig" => "html", ".css" => "css", ".scss" => "css",
+          ".md" => "markdown", ".sql" => "sql", ".yaml" => "yaml",
+          ".yml" => "yaml", ".toml" => "toml", ".xml" => "html",
+          ".env" => "env",
+          ".sh" => "shell", ".bash" => "shell",
+          ".bat" => "shell", ".cmd" => "shell", ".ps1" => "shell",
+          ".rs" => "rust", ".go" => "go", ".java" => "java",
+          ".txt" => "text", ".csv" => "text", ".log" => "text",
+          ".gemspec" => "ruby", ".rake" => "ruby",
+          ".svg" => "svg"
+        }
+        ext_map.fetch(File.extname(base).downcase, "text")
       end
 
       def file_read_payload(rel)
@@ -1285,7 +1425,7 @@ module Tina4
           return { error: "Not found" } unless File.exist?(target)
           return { error: "Not a file" } unless File.file?(target)
           content = File.read(target, encoding: "utf-8", invalid: :replace, undef: :replace)
-          { path: rel, content: content, bytes: File.size(target) }
+          { path: rel, content: content, bytes: File.size(target), language: dev_admin_language(rel) }
         rescue => e
           { error: e.message }
         end