markdownr 0.8.0 → 0.8.1

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/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.8.0"
+  VERSION = "0.8.1"
 end