markdownr 0.7.2 → 0.8.1

data/lib/markdown_server/helpers/markdown_helpers.rb

@@ -73,7 +73,7 @@ module MarkdownServer
             %(<sup id="fnref:#{name}" role="doc-noteref"><a href="#fn:#{name}" class="footnote" rel="footnote">#{h(name)}</a></sup>)
           end
         end
-        html.gsub(%r{<li id="fn:([^"]+)"[^>]*>\s*<p>}m) do
+        html = html.gsub(%r{<li id="fn:([^"]+)"[^>]*>\s*<p>}m) do
           full_match = $&
           name = $1
           if name =~ /\A\d+\z/
@@ -82,6 +82,107 @@ module MarkdownServer
             %(<li id="fn:#{name}"><p><strong>#{h(name)}:</strong> )
           end
         end
+
+        transform_callouts(html)
+      end
+
+      # Obsidian-style callouts: `> [!TYPE] Optional Title` at the start of a
+      # blockquote becomes a styled .callout panel. `[!TYPE]+` makes it a
+      # foldable <details open>; `[!TYPE]-` makes it foldable and collapsed.
+      CALLOUT_TYPES = {
+        "note"     => { label: "Note",     color: "#448aff" },
+        "abstract" => { label: "Abstract", color: "#00b0ff" },
+        "summary"  => { label: "Summary",  color: "#00b0ff" },
+        "tldr"     => { label: "TL;DR",    color: "#00b0ff" },
+        "info"     => { label: "Info",     color: "#00b8d4" },
+        "todo"     => { label: "Todo",     color: "#00b8d4" },
+        "tip"      => { label: "Tip",      color: "#00bfa5" },
+        "hint"     => { label: "Hint",     color: "#00bfa5" },
+        "important"=> { label: "Important",color: "#00bfa5" },
+        "success"  => { label: "Success",  color: "#00c853" },
+        "check"    => { label: "Check",    color: "#00c853" },
+        "done"     => { label: "Done",     color: "#00c853" },
+        "question" => { label: "Question", color: "#64dd17" },
+        "help"     => { label: "Help",     color: "#64dd17" },
+        "faq"      => { label: "FAQ",      color: "#64dd17" },
+        "warning"  => { label: "Warning",  color: "#ff9100" },
+        "caution"  => { label: "Caution",  color: "#ff9100" },
+        "attention"=> { label: "Attention",color: "#ff9100" },
+        "failure"  => { label: "Failure",  color: "#ff5252" },
+        "fail"     => { label: "Fail",     color: "#ff5252" },
+        "missing"  => { label: "Missing",  color: "#ff5252" },
+        "danger"   => { label: "Danger",   color: "#ff1744" },
+        "error"    => { label: "Error",    color: "#ff1744" },
+        "bug"      => { label: "Bug",      color: "#f50057" },
+        "example"  => { label: "Example",  color: "#7c4dff" },
+        "quote"    => { label: "Quote",    color: "#9e9e9e" },
+        "cite"     => { label: "Cite",     color: "#9e9e9e" }
+      }.freeze
+
+      CALLOUT_ICONS = {
+        "note"     => '<path d="M12 20h9"/><path d="M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4z"/>',
+        "abstract" => '<path d="M9 5H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2"/><rect x="9" y="3" width="6" height="4" rx="1"/><path d="M9 12h6M9 16h6"/>',
+        "info"     => '<circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/>',
+        "todo"     => '<circle cx="12" cy="12" r="10"/><polyline points="9 12 11 14 15 10"/>',
+        "tip"      => '<path d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z"/>',
+        "success"  => '<polyline points="20 6 9 17 4 12"/>',
+        "question" => '<circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+        "warning"  => '<path d="M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+        "failure"  => '<circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/>',
+        "danger"   => '<polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>',
+        "bug"      => '<rect x="8" y="6" width="8" height="14" rx="4"/><path d="M19 7l-3 2M5 7l3 2M19 13h-3M8 13H5M19 19l-3-2M5 19l3-2M9 2l1 2M15 2l-1 2"/>',
+        "example"  => '<line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/>',
+        "quote"    => '<path d="M3 21c3 0 7-1 7-8V5c0-1.25-.756-2.017-2-2H4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2 1 0 1 0 1 1v1c0 1-1 2-2 2s-1 .008-1 1.031V20c0 1 0 1 1 1z"/><path d="M15 21c3 0 7-1 7-8V5c0-1.25-.757-2.017-2-2h-4c-1.25 0-2 .75-2 1.972V11c0 1.25.75 2 2 2h.75c0 2.25.25 4-2.75 4v3c0 1 0 1 1 1z"/>'
+      }.freeze
+
+      CALLOUT_ICON_ALIASES = {
+        "summary" => "abstract", "tldr" => "abstract",
+        "hint" => "tip", "important" => "tip",
+        "check" => "success", "done" => "success",
+        "help" => "question", "faq" => "question",
+        "caution" => "warning", "attention" => "warning",
+        "fail" => "failure", "missing" => "failure",
+        "error" => "danger",
+        "cite" => "quote"
+      }.freeze
+
+      def callout_meta(type)
+        CALLOUT_TYPES[type] || { label: type.capitalize, color: "#888888" }
+      end
+
+      def callout_icon_svg(type)
+        key = CALLOUT_ICON_ALIASES[type] || type
+        body = CALLOUT_ICONS[key] || CALLOUT_ICONS["note"]
+        %(<svg class="callout-icon" viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">#{body}</svg>)
+      end
+
+      def transform_callouts(html)
+        html.gsub(
+          %r{<blockquote>\s*<p>\[!(\w+)\]([+-])?[ \t]*([^\n<]*?)[ \t]*(?:<br\s*/?>\n?|\n)?(.*?)</p>(.*?)</blockquote>}m
+        ) do
+          type = $1.downcase
+          fold = $2
+          custom_title = $3.to_s.strip
+          first_p_rest = $4.to_s.strip
+          rest = $5.to_s.strip
+
+          meta = callout_meta(type)
+          title = custom_title.empty? ? meta[:label] : custom_title
+
+          body = +""
+          body << "<p>#{first_p_rest}</p>" unless first_p_rest.empty?
+          body << rest
+
+          icon = callout_icon_svg(type)
+          title_html = %(#{icon}<span class="callout-title-inner">#{h(title)}</span>)
+
+          if fold
+            open_attr = fold == "+" ? " open" : ""
+            %(<div class="callout callout-#{type}" data-callout="#{type}" style="--callout-color: #{meta[:color]}"><details#{open_attr}><summary class="callout-title">#{title_html}</summary><div class="callout-content">#{body}</div></details></div>)
+          else
+            %(<div class="callout callout-#{type}" data-callout="#{type}" style="--callout-color: #{meta[:color]}"><div class="callout-title">#{title_html}</div><div class="callout-content">#{body}</div></div>)
+          end
+        end
       end
 
       def resolve_wiki_link(name)
@@ -101,8 +202,7 @@ module MarkdownServer
               real = File.realpath(path) rescue next
               next unless real.start_with?(base)
               relative = real.sub("#{base}/", "")
-              first_segment = relative.split("/").first
-              next if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
+              next unless MarkdownServer::Unhide.visible?(relative.split("/"), Array(settings.unhide_rules))
               if File.basename(real) == filename
                 local_exact = relative
                 break
@@ -124,8 +224,7 @@ module MarkdownServer
             real = File.realpath(path) rescue next
             next unless real.start_with?(base)
             relative = real.sub("#{base}/", "")
-            first_segment = relative.split("/").first
-            next if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
+            next unless MarkdownServer::Unhide.visible?(relative.split("/"), Array(settings.unhide_rules))
             if File.basename(real) == filename
               exact_match ||= relative
             else
@@ -203,6 +302,34 @@ module MarkdownServer
         formatter.format(lexer.lex(code))
       end
 
+      def detect_source_language(real_path, content)
+        ext = File.extname(real_path).downcase
+        by_ext = case ext
+                 when ".py" then "python"
+                 when ".rb" then "ruby"
+                 when ".csv" then "text"
+                 when ".sh" then "bash"
+                 when ".yaml", ".yml" then "yaml"
+                 when ".erb" then "html"
+                 when ".html" then "html"
+                 when ".js" then "javascript"
+                 when ".css" then "css"
+                 when ".json" then "json"
+                 end
+        return by_ext if by_ext
+
+        if content.is_a?(String) && content.start_with?("#!")
+          shebang = content.lines.first.to_s
+          return "ruby"       if shebang.match?(/\bruby\b/)
+          return "python"     if shebang.match?(/\bpython[\d.]*\b/)
+          return "bash"       if shebang.match?(/\b(bash|zsh|dash|ksh|sh)\b/)
+          return "javascript" if shebang.match?(/\bnode\b/)
+          return "perl"       if shebang.match?(/\bperl\b/)
+        end
+
+        "text"
+      end
+
       def extract_toc(html)
         headings = []
         html.scan(/<h([1-6])\s[^>]*id="([^"]*)"[^>]*>(.*?)<\/h\1>/mi) do |level, id, text|

data/lib/markdown_server/helpers/path_helpers.rb

@@ -13,6 +13,27 @@ module MarkdownServer
         URI.encode_www_form_component(str).gsub("+", "%20")
       end
 
+      # Returns the permitted base (root realpath or a followed-link target realpath)
+      # that contains `real`, or nil if no permitted base contains it.
+      def permitted_base_for(real)
+        MarkdownServer::PermittedBases.base_for(real, permitted_bases)
+      end
+
+      def permitted_bases
+        [File.realpath(root_dir), *Array(settings.followed_links)]
+      end
+
+      # Returns true if `real` is under a permitted base AND every restricted
+      # segment of the path under that base is admitted by the configured
+      # unhide rules (per Unhide.visible? algorithm).
+      def permitted_path?(real)
+        base = permitted_base_for(real)
+        return false unless base
+        return true if real == base
+        rel = real.sub("#{base}/", "")
+        MarkdownServer::Unhide.visible?(rel.split("/"), Array(settings.unhide_rules))
+      end
+
       def safe_path(requested)
         base = File.realpath(root_dir)
         full = File.join(base, requested)
@@ -23,17 +44,45 @@ module MarkdownServer
           halt 404, erb(:layout) { "<h1>Not Found</h1><p>#{h(requested)}</p>" }
         end
 
-        unless real.start_with?(base)
-          halt 403, erb(:layout) { "<h1>Forbidden</h1>" }
+        halt 403, erb(:layout) { "<h1>Forbidden</h1>" } unless permitted_path?(real)
+        real
+      end
+
+      # Name-gate check for an entry in a directory listing.
+      #
+      # Boundary gate (against served root) is NOT applied here so non-followed
+      # external non-dot symlinks still appear in listings — matching today's
+      # UX; clicking them produces a 403 via safe_path/permitted_path?.
+      #
+      # When the name gate admits a normally-restricted entry (dotfile or
+      # EXCLUDED) that is also a symlink, additionally require the symlink's
+      # realpath to be explicitly listed in --follow-link. Otherwise the
+      # unhide rule does not surface it. Keeps `unhide` (visibility by name)
+      # and `--follow-link` (which symlinks may be entered) as orthogonal
+      # opt-ins; prevents internal-aliased dotfile symlinks like
+      # `.claude → claude` from showing up as duplicates of their targets.
+      def entry_admitted?(parent_real, parent_relative_str, entry_name)
+        rules = Array(settings.unhide_rules)
+        parent_segs = parent_relative_str.to_s.empty? ? [] : parent_relative_str.split("/")
+
+        mode = :open
+        parent_segs.each_with_index do |seg, i|
+          ok, mode = MarkdownServer::Unhide.step(mode, parent_segs, i, seg, rules)
+          return false unless ok
         end
 
-        relative = real.sub("#{base}/", "")
-        first_segment = relative.split("/").first
-        if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
-          halt 403, erb(:layout) { "<h1>Forbidden</h1>" }
+        ok, _ = MarkdownServer::Unhide.entry_step(mode, parent_segs, entry_name, rules)
+        return false unless ok
+
+        if MarkdownServer::Unhide.restricted?(entry_name)
+          full = File.join(parent_real, entry_name)
+          if File.symlink?(full)
+            real = File.realpath(full) rescue (return false)
+            return false unless Array(settings.followed_links).include?(real)
+          end
         end
 
-        real
+        true
       end
     end
   end

data/lib/markdown_server/helpers/search_helpers.rb

@@ -60,13 +60,41 @@ module MarkdownServer
         results
       end
 
-      def walk_directory(dir_path, &block)
+      def walk_directory(dir_path, parent_segs = nil, parent_mode = nil, &block)
+        rules = Array(settings.unhide_rules)
+        bases = permitted_bases
+
+        if parent_segs.nil?
+          base = File.realpath(root_dir)
+          real_dir = File.realpath(dir_path) rescue dir_path
+          parent_segs = (real_dir == base || !real_dir.start_with?("#{base}/")) ? [] : real_dir.sub("#{base}/", "").split("/")
+          parent_mode = :open
+          parent_segs.each_with_index do |seg, i|
+            ok, parent_mode = MarkdownServer::Unhide.step(parent_mode, parent_segs, i, seg, rules)
+            return unless ok
+          end
+        end
+
         Dir.entries(dir_path).sort.each do |entry|
-          next if entry.start_with?(".") || EXCLUDED.include?(entry)
+          next if entry == "." || entry == ".."
+
+          visible, child_mode = MarkdownServer::Unhide.entry_step(parent_mode, parent_segs, entry, rules)
+          next unless visible
+
           full = File.join(dir_path, entry)
+          real = File.realpath(full) rescue next
+          next unless MarkdownServer::PermittedBases.base_for(real, bases)
+
+          # Restricted entries that are symlinks: only descend / index when
+          # the symlink's realpath is explicitly in --follow-link. Mirrors
+          # entry_admitted? in path_helpers; prevents unhide from
+          # double-walking internal-aliased dotfile symlinks.
+          if MarkdownServer::Unhide.restricted?(entry) && File.symlink?(full)
+            next unless Array(settings.followed_links).include?(real)
+          end
 
           if File.directory?(full)
-            walk_directory(full, &block)
+            walk_directory(full, parent_segs + [entry], child_mode, &block)
           elsif File.file?(full)
             ext = File.extname(entry).downcase
             next if BINARY_EXTENSIONS.include?(ext)

data/lib/markdown_server/permitted_bases.rb

@@ -0,0 +1,13 @@
+module MarkdownServer
+  module PermittedBases
+    # Returns the permitted base (one of `bases`) that contains `real`,
+    # or nil if no base contains it. Each base is the realpath of the
+    # served root or a --follow-link target.
+    def self.base_for(real, bases)
+      Array(bases).each do |b|
+        return b if real == b || real.start_with?("#{b}/")
+      end
+      nil
+    end
+  end
+end

data/lib/markdown_server/plugin.rb

@@ -33,6 +33,10 @@ module MarkdownServer
 
     # Hook: post-process rendered markdown HTML (runs after render_markdown)
     def post_render(html, meta, app) html end
+
+    # Hook: claim a file for custom popup rendering in /browser
+    # Return { type:, title:, ... } hash or nil to pass
+    def browser_render(relative_path, real_path, app) nil end
   end
 
   class PluginRegistry
@@ -53,6 +57,13 @@ module MarkdownServer
         end
 
         config = resolve_config(root_dir, cli_overrides)
+        known_names = registered.map(&:plugin_name)
+        config.each do |name, cfg|
+          next unless cfg.is_a?(Hash) && cfg["enabled"]
+          unless known_names.include?(name)
+            $stderr.puts "\n\e[1;33mWarning: unknown plugin '#{name}' (available: #{known_names.join(", ")})\e[0m\n\n"
+          end
+        end
         registered.filter_map do |klass|
           plugin_config = config.fetch(klass.plugin_name, {})
           enabled = plugin_config.fetch("enabled", klass.enabled_by_default?)

data/lib/markdown_server/plugins/bible_citations/citations.rb

@@ -90,18 +90,18 @@ module MarkdownServer
       end
 
       def self.scrip_url(canonical, verse, version: DEFAULT_VERSION)
-        # Parse chapter and optional starting verse from the verse string
+        # Parse chapter and optional verse range from the verse string
         # verse is e.g. "1:1", "1:1-5", "1", "1-2", "1:1,3,5"
-        if verse =~ /\A(\d+)(?::(\d+))?/
+        if verse =~ /\A(\d+)(?::(\d+(?:[–—\-]\d+)?))?/
           chapter = format("%03d", $1.to_i)
-          start_verse = $2
+          verse_part = $2&.gsub(/[–—]/, "-")
         else
           return biblegateway_url(canonical, verse, version: version)
         end
 
         encode = ->(s) { URI.encode_www_form_component(s).gsub("+", "%20") }
         url = "https://scrip.risensavior.com/browse/#{encode[version]}/#{encode[canonical]}/#{chapter}.html"
-        url += "#v#{start_verse}" if start_verse
+        url += "#v#{verse_part}" if verse_part
         url
       end
 

data/lib/markdown_server/unhide.rb

@@ -0,0 +1,114 @@
+module MarkdownServer
+  module Unhide
+    Rule = Struct.new(:kind, :segments)
+
+    class CompileError < StandardError; end
+
+    def self.compile(raw_entries)
+      Array(raw_entries).compact.map { |e| compile_one(e) }.uniq
+    end
+
+    def self.compile_one(raw)
+      entry = raw.to_s.strip
+      raise CompileError, "unhide entry is empty" if entry.empty?
+
+      if entry.start_with?("@/")
+        path = entry.sub(%r{^@/+}, "")
+        raise CompileError, "unhide entry '#{raw}' has no path after '@/'" if path.empty?
+        segments = normalize_segments(path)
+        raise CompileError, "unhide entry '#{raw}' has no usable segments" if segments.empty?
+        Rule.new(:anchored, segments)
+      else
+        if entry.start_with?("/")
+          raise CompileError,
+                "unhide entry '#{raw}' has a leading '/'. " \
+                "Use '@/...' for project-root-anchored, or omit the slash for any-depth match."
+        end
+        segments = normalize_segments(entry)
+        raise CompileError, "unhide entry '#{raw}' has no usable segments" if segments.empty?
+        Rule.new(segments.length == 1 ? :basename : :suffix, segments)
+      end
+    end
+
+    def self.normalize_segments(path)
+      path.split("/").reject(&:empty?)
+    end
+
+    def self.restricted?(name)
+      return false if name.nil? || name.empty?
+      name.start_with?(".") || MarkdownServer::EXCLUDED.include?(name)
+    end
+
+    # Returns :leaf if any rule matches segment i as its leaf,
+    # :prefix if any rule matches segment i as a navigational prefix,
+    # :none otherwise.
+    def self.match_at(path_segs, i, rules)
+      best = :none
+      rules.each do |r|
+        case r.kind
+        when :basename
+          return :leaf if r.segments[0] == path_segs[i]
+        when :suffix
+          r.segments.length.times do |k|
+            next unless i >= k
+            next unless path_segs[(i - k)..i] == r.segments[0..k]
+            if k + 1 == r.segments.length
+              return :leaf
+            else
+              best = :prefix
+            end
+          end
+        when :anchored
+          if i < r.segments.length && path_segs[0..i] == r.segments[0..i]
+            if i + 1 == r.segments.length
+              return :leaf
+            else
+              best = :prefix
+            end
+          end
+        end
+      end
+      best
+    end
+
+    # Cold check: walks segment by segment from root, tracking mode.
+    # Returns true iff every segment of path_segments is admitted.
+    def self.visible?(path_segments, rules)
+      mode = :open
+      path_segments.each_with_index do |seg, i|
+        visible, mode = step(mode, path_segments, i, seg, rules)
+        return false unless visible
+      end
+      true
+    end
+
+    # Amortized step for an enumeration. parent_mode and parent_segs are known
+    # from the enclosing recursion; this checks one entry. Returns [visible, child_mode].
+    def self.entry_step(parent_mode, parent_segs, entry_name, rules)
+      path_segs = parent_segs + [entry_name]
+      step(parent_mode, path_segs, path_segs.length - 1, entry_name, rules)
+    end
+
+    def self.step(mode, path_segs, i, seg, rules)
+      restricted = restricted?(seg)
+
+      if restricted
+        case match_at(path_segs, i, rules)
+        when :leaf   then [true, :open]
+        when :prefix then [true, :narrow]
+        else              [false, nil]
+        end
+      else
+        if mode == :open
+          [true, :open]
+        else
+          case match_at(path_segs, i, rules)
+          when :leaf   then [true, :open]
+          when :prefix then [true, :narrow]
+          else              [false, nil]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markdown_server/version.rb

@@ -1,3 +1,3 @@
 module MarkdownServer
-  VERSION = "0.7.2"
+  VERSION = "0.8.1"
 end