jekyll-relative-links 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a52004700c904303c029534ffabb2d4219b2680f0f0ab3e6503bec3590a03b5
-  data.tar.gz: a4f0aaeeec9d1613304f0592dda8eff220a9efb9a94a1d48ab6b8058b4a08ead
+  metadata.gz: 3ebb41a644bab20c56e388f5b63e9fcaea9e8405de7c6af7853b7b30ca80b5bd
+  data.tar.gz: 12fd6b72f8fe9acde53c5fe8059a409610b6d808d63c888e7585de25b93a2160
 SHA512:
-  metadata.gz: cd5cea8919a1a671a6809abd815556339e193c9c0ed69cf27f10674124cd47f087f032df68cdacfa3b17058fbda2ad707b7bb9a845a118347f3a81dc737c2bb2
-  data.tar.gz: 0b837f08ffc3e18e0e5c49186c7cb2ba8a2d05093ad67084e07562c5aaa88578a0e41169fbaf16b6f6e3edd26d550fd5b0a14afc81ff82deadcd547fc6364700
+  metadata.gz: eb15617682d0df090db9ab9a25ae69c9fd8d50188a2ec49d7fa1a873d01e3ddbf638085ec0620c2a6cdc1a65f38e15f7615385c0132da974c496d0dab7f1b455
+  data.tar.gz: 5acc91f26ba6c9ee15341bf0575fc72c7ec4174166cbbc1c602ed80384a518702b74558b61dae9b0ac8f1cbcbb3c2c01eefc98d136dad5b04e0ed8b8170b0447

data/lib/jekyll-relative-links/filter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module JekyllRelativeLinks
+  module Filter
+    # This filter processes HTML content that's already been converted by the markdownify
+    # filter and updates any relative links to markdown files to point to their HTML equivalents.
+    # Usage: {{ content | markdownify | rellinks }}
+    def rellinks(html)
+      return html if html.nil? || html.empty?
+      return html if @context.registers[:site].nil?
+
+      process_links(html, @context.registers[:site])
+    end
+
+    def process_links(html, site)
+      page = @context.registers[:page]
+      url_base = page ? File.dirname(page["path"].to_s) : ""
+
+      html.gsub(%r!<a href="([^"]+\.md)(#([^"]+))?"!) do |match|
+        process_link(match, Regexp.last_match, url_base, site)
+      end
+    end
+
+    def process_link(match, regex_match, url_base, site)
+      relative_path = regex_match[1]
+      fragment = regex_match[3] ? "##{regex_match[3]}" : ""
+
+      return match if absolute_url?(relative_path) || !relative_path.end_with?(".md")
+
+      path = path_from_root(relative_path, url_base)
+      url = url_for_path(path, site)
+      url ? "<a href=\"#{url}#{fragment}\"" : match
+    end
+
+    private
+
+    def absolute_url?(string)
+      return false unless string
+
+      Addressable::URI.parse(string).absolute?
+    rescue Addressable::URI::InvalidURIError
+      false
+    end
+
+    def path_from_root(relative_path, url_base)
+      is_absolute = relative_path.start_with? "/"
+
+      relative_path.delete_prefix!("/")
+      base = is_absolute ? "" : url_base
+      absolute_path = File.expand_path(relative_path, base)
+      absolute_path.sub(%r!\A#{Regexp.escape(Dir.pwd)}/!, "")
+    end
+
+    def url_for_path(path, site)
+      path = CGI.unescape(path)
+      potential_targets = site.pages + site.static_files + site.docs_to_write
+      target = potential_targets.find { |p| p.relative_path.delete_prefix("/") == path }
+      relative_url(target.url) if target&.url
+    end
+  end
+end
+
+Liquid::Template.register_filter(JekyllRelativeLinks::Filter)

data/lib/jekyll-relative-links/generator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "cgi"
+
 module JekyllRelativeLinks
   class Generator < Jekyll::Generator
     attr_accessor :site, :config
@@ -7,10 +9,17 @@ module JekyllRelativeLinks
     # Use Jekyll's native relative_url filter
     include Jekyll::Filters::URLFilters
 
-    LINK_TEXT_REGEX = %r!(.*?)!.freeze
-    FRAGMENT_REGEX = %r!(#.+?)?!.freeze
-    INLINE_LINK_REGEX = %r!\[#{LINK_TEXT_REGEX}\]\(([^\)]+?)#{FRAGMENT_REGEX}\)!.freeze
-    REFERENCE_LINK_REGEX = %r!^\s*?\[#{LINK_TEXT_REGEX}\]: (.+?)#{FRAGMENT_REGEX}\s*?$!.freeze
+    # Matches link text, including images like ![alt](url) or ![alt]
+    # Pattern explanation:
+    # - !\[[^\]]*\](?:\([^\)]*\))? matches complete image patterns: ![...](...) or ![...]
+    # - (?!\]\() uses negative lookahead to match any char except when followed by ](
+    #   This allows nested ] while stopping at the correct closing bracket
+    LINK_TEXT_REGEX = %r{((?:!\[[^\]]*\](?:\([^\)]*\))?|(?!\]\().)*?)}.freeze
+    FRAGMENT_REGEX = %r!(#.+?|)?!.freeze
+    TITLE_REGEX = %r{(\s+"(?:\\"|[^"])*(?<!\\)"|\s+"(?:\\'|[^'])*(?<!\\)')?}.freeze
+    FRAG_AND_TITLE_REGEX = %r!#{FRAGMENT_REGEX}#{TITLE_REGEX}!.freeze
+    INLINE_LINK_REGEX = %r!\[#{LINK_TEXT_REGEX}\]\(([^)]+?)#{FRAG_AND_TITLE_REGEX}\)!.freeze
+    REFERENCE_LINK_REGEX = %r!^\s*?\[#{LINK_TEXT_REGEX}\]: (.+?)#{FRAG_AND_TITLE_REGEX}\s*?$!.freeze
     LINK_REGEX = %r!(#{INLINE_LINK_REGEX}|#{REFERENCE_LINK_REGEX})!.freeze
     CONVERTER_CLASS = Jekyll::Converters::Markdown
     CONFIG_KEY = "relative_links"
@@ -48,27 +57,35 @@ module JekyllRelativeLinks
       return document if document.content.nil?
 
       document.content = document.content.dup.gsub(LINK_REGEX) do |original|
-        link_type, link_text, relative_path, fragment = link_parts(Regexp.last_match)
-        next original unless replaceable_link?(relative_path)
+        link = link_parts(Regexp.last_match)
+        next original unless replaceable_link?(link.path)
 
-        path = path_from_root(relative_path, url_base)
+        path = path_from_root(CGI.unescape(link.path), url_base)
         url  = url_for_path(path)
         next original unless url
 
-        replacement_text(link_type, link_text, url, fragment)
+        link.path = url
+        replacement_text(link)
       end
+
+      replace_relative_links_excerpt!(document)
     rescue ArgumentError => e
       raise e unless e.to_s.start_with?("invalid byte sequence in UTF-8")
     end
 
     private
 
+    # Stores info on a Markdown Link (avoid rubocop's Metrics/ParameterLists warning)
+    Link = Struct.new(:link_type, :text, :path, :fragment, :title)
+
     def link_parts(matches)
-      link_type     = matches[2] ? :inline : :reference
-      link_text     = matches[link_type == :inline ? 2 : 5]
-      relative_path = matches[link_type == :inline ? 3 : 6]
-      fragment      = matches[link_type == :inline ? 4 : 7]
-      [link_type, link_text, relative_path, fragment]
+      last_inline = 5
+      link_type = matches[2] ? :inline : :reference
+      link_text = matches[link_type == :inline ? 2 : last_inline + 1]
+      relative_path = matches[link_type == :inline ? 3 : last_inline + 2]
+      fragment = matches[link_type == :inline ? 4 : last_inline + 3]
+      title = matches[link_type == :inline ? 5 : last_inline + 4]
+      Link.new(link_type, link_text, relative_path, fragment, title)
     end
 
     def context
@@ -84,7 +101,7 @@ module JekyllRelativeLinks
     end
 
     def url_for_path(path)
-      target = potential_targets.find { |p| p.relative_path.sub(%r!\A/!, "") == path }
+      target = potential_targets_by_path[path]
       relative_url(target.url) if target&.url
     end
 
@@ -92,28 +109,45 @@ module JekyllRelativeLinks
       @potential_targets ||= site.pages + site.static_files + site.docs_to_write
     end
 
+    # Index `potential_targets` by the same key the previous linear `find`
+    # compared against, so each `url_for_path` lookup is O(1) instead of
+    # O(N). On a site with M markdown link matches and N potential
+    # targets, total link-resolution cost goes from O(M*N) to O(M+N).
+    # First-wins semantics are preserved against the (unlikely) case of
+    # two targets sharing the same `relative_path`.
+    def potential_targets_by_path
+      @potential_targets_by_path ||= potential_targets.each_with_object({}) do |p, h|
+        key = p.relative_path.sub(%r!\A/!, "")
+        h[key] = p unless h.key?(key)
+      end
+    end
+
     def path_from_root(relative_path, url_base)
+      is_absolute = relative_path.start_with? "/"
+
       relative_path.sub!(%r!\A/!, "")
-      absolute_path = File.expand_path(relative_path, url_base)
+      base = is_absolute ? "" : url_base
+      absolute_path = File.expand_path(relative_path, base)
       absolute_path.sub(%r!\A#{Regexp.escape(Dir.pwd)}/!, "")
     end
 
-    def replacement_text(type, text, url, fragment = nil)
-      url << fragment if fragment
+    # @param link [Link] A Link object describing the markdown link to make
+    def replacement_text(link)
+      link.path << link.fragment if link.fragment
 
-      if type == :inline
-        "[#{text}](#{url})"
+      if link.link_type == :inline
+        "[#{link.text}](#{link.path}#{link.title})"
       else
-        "\n[#{text}]: #{url}"
+        "\n[#{link.text}]: #{link.path}#{link.title}"
       end
     end
 
     def absolute_url?(string)
-      return unless string
+      return false unless string
 
       Addressable::URI.parse(string).absolute?
     rescue Addressable::URI::InvalidURIError
-      nil
+      false
     end
 
     def fragment?(string)
@@ -153,5 +187,11 @@ module JekyllRelativeLinks
     def global_entry_filter
       @global_entry_filter ||= Jekyll::EntryFilter.new(site)
     end
+
+    def replace_relative_links_excerpt!(document)
+      return unless document.data["excerpt"] && !document.data["excerpt"].is_a?(String)
+
+      document.data["excerpt"] = Jekyll::Excerpt.new(document)
+    end
   end
 end

data/lib/jekyll-relative-links/hooks.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module JekyllRelativeLinks
+  # Register Jekyll hooks to process HTML output after conversion
+  Jekyll::Hooks.register :pages, :post_render do |page|
+    next unless JekyllRelativeLinks::Hooks.should_process?(page, page.site.config)
+
+    page.output = JekyllRelativeLinks::Hooks.process_html_links(page.output, page, page.site)
+  end
+
+  Jekyll::Hooks.register :documents, :post_render do |document|
+    next unless JekyllRelativeLinks::Hooks.should_process_document?(document, document.site.config)
+
+    document.output = JekyllRelativeLinks::Hooks.process_html_links(document.output, document,
+                                                                    document.site)
+  end
+
+  module Hooks
+    CONVERTER_CLASS = Jekyll::Converters::Markdown
+    CONFIG_KEY = "relative_links"
+    ENABLED_KEY = "enabled"
+    COLLECTIONS_KEY = "collections"
+
+    # Regex to match markdown links in HTML: <a href="*.md">
+    # Capture groups:
+    #   (1) attributes before href, (2) the .md path,
+    #   (3) optional fragment, (4) attributes after href
+    MARKDOWN_LINK_IN_HTML = %r!<a\s+([^>]*?\s+)?href="([^"]+\.md)(#[^"]*)?"\s*([^>]*)>!m.freeze
+
+    def self.should_process?(page, config)
+      return false if disabled?(config)
+      return false unless markdown_extension?(page.extname, page.site)
+      return false if excluded?(page, config, page.site)
+
+      true
+    end
+
+    def self.should_process_document?(document, config)
+      return false if disabled?(config)
+      return false unless collections_enabled?(config)
+      return false unless markdown_extension?(document.extname, document.site)
+      return false if excluded?(document, config, document.site)
+
+      true
+    end
+
+    def self.disabled?(config)
+      config[CONFIG_KEY] && config[CONFIG_KEY][ENABLED_KEY] == false
+    end
+
+    def self.collections_enabled?(config)
+      config[CONFIG_KEY] && config[CONFIG_KEY][COLLECTIONS_KEY] == true
+    end
+
+    def self.markdown_extension?(extension, site)
+      converter = site.find_converter_instance(CONVERTER_CLASS)
+      converter.matches(extension)
+    end
+
+    def self.excluded?(document, config, site)
+      return false unless config[CONFIG_KEY] && config[CONFIG_KEY]["exclude"]
+
+      entry_filter = if document.respond_to?(:collection)
+                       document.collection.entry_filter
+                     else
+                       Jekyll::EntryFilter.new(site)
+                     end
+
+      entry_filter.glob_include?(config[CONFIG_KEY]["exclude"], document.relative_path)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def self.process_html_links(html, document, site)
+      return html if html.nil? || html.empty?
+
+      url_base = File.dirname(document.relative_path)
+      potential_targets = site.pages + site.static_files + site.docs_to_write
+
+      # Process <a href="*.md"> links that were added via includes
+      # rubocop:disable Metrics/BlockLength
+      html.gsub(MARKDOWN_LINK_IN_HTML) do |match|
+        attributes_before = Regexp.last_match[1] || ""
+        relative_path = Regexp.last_match[2]
+        fragment = Regexp.last_match[3] || ""
+        attributes_after = Regexp.last_match[4] || ""
+
+        # Skip absolute URLs
+        begin
+          next match if Addressable::URI.parse(relative_path).absolute?
+        rescue Addressable::URI::InvalidURIError
+          next match
+        end
+
+        # Calculate path from root
+        is_absolute = relative_path.start_with?("/")
+        relative_path_clean = relative_path.delete_prefix("/")
+        base = is_absolute ? "" : url_base
+        absolute_path = File.expand_path(relative_path_clean, base)
+        path = absolute_path.sub(%r!\A#{Regexp.escape(Dir.pwd)}/!, "")
+
+        # Find the target page and get its URL
+        path = CGI.unescape(path)
+        target = potential_targets.find { |p| p.relative_path.delete_prefix("/") == path }
+
+        if target&.url
+          # Use Jekyll's URL
+          url = target.url
+          url = "/#{url}" unless url.start_with?("/")
+
+          # Build the replacement ensuring proper spacing
+          attrs = []
+          attrs << attributes_before.strip unless attributes_before.empty?
+          attrs << "href=\"#{url}#{fragment}\""
+          attrs << attributes_after.strip unless attributes_after.empty?
+          "<a #{attrs.join(" ")}>"
+        else
+          match
+        end
+      end
+      # rubocop:enable Metrics/BlockLength
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/jekyll-relative-links/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JekyllRelativeLinks
-  VERSION = "0.6.1"
+  VERSION = "0.8.0"
 end

data/lib/jekyll-relative-links.rb

@@ -3,6 +3,8 @@
 require "jekyll"
 require_relative "jekyll-relative-links/generator"
 require_relative "jekyll-relative-links/context"
+require_relative "jekyll-relative-links/filter"
+require_relative "jekyll-relative-links/hooks"
 
 module JekyllRelativeLinks
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-relative-links
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Ben Balter
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -30,6 +29,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -50,14 +63,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.71'
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.26.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.71'
+        version: 2.26.0
 - !ruby/object:Gem::Dependency
   name: rubocop-jekyll
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +99,90 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
-description: 
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tsort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - ben.balter@github.com
 executables: []
@@ -81,13 +191,14 @@ extra_rdoc_files: []
 files:
 - lib/jekyll-relative-links.rb
 - lib/jekyll-relative-links/context.rb
+- lib/jekyll-relative-links/filter.rb
 - lib/jekyll-relative-links/generator.rb
+- lib/jekyll-relative-links/hooks.rb
 - lib/jekyll-relative-links/version.rb
 homepage: https://github.com/benbalter/jekyll-relative-links
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -102,8 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A Jekyll plugin to convert relative links to markdown files to their rendered
   equivalents.