swedbank-pay-design-guide-jekyll-theme 1.7 → 1.9.1

data/lib/sidebar_page_collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: false
+
+require 'forwardable'
+
+module SwedbankPay
+  # Arranges Sidebar pages into a tree
+  class SidebarPageCollection
+    include Enumerable
+    extend Forwardable
+    def_delegators :@pages, :each, :length, :empty?, :[]
+
+    def initialize(parent, pages = [])
+      raise ArgumentError, 'Pages must be an array' unless pages.is_a? Array
+
+      @pages = []
+
+      pages.each_with_index do |page, index|
+        page.number = index
+        page.parent = parent
+        page.freeze
+        @pages.push(page)
+      end
+    end
+
+    def count
+      return 0 if @pages.empty?
+
+      count = @pages.length
+
+      @pages.each do |page|
+        count += page.children.count
+      end
+
+      count
+    end
+  end
+end

data/lib/sidebar_page_title.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'jekyll'
+require_relative 'sidebar_page'
+
+module SwedbankPay
+  # Represents the title of a SidebarPage
+  class SidebarPageTitle
+    attr_reader :main, :section
+
+    def self.parse(jekyll_page, sidebar_page)
+      raise ArgumentError, 'jekyll_page cannot be nil' if jekyll_page.nil?
+      raise ArgumentError, 'jekyll_page must be a Jekyll::Page' unless jekyll_page.is_a? Jekyll::Page
+      raise ArgumentError, 'sidebar_page cannot be nil' if sidebar_page.nil?
+      raise ArgumentError, 'sidebar_page must be a SidebarPage' unless sidebar_page.is_a? SidebarPage
+
+      title = jekyll_page['title']
+      section = jekyll_page['section']
+      return nil if title.nil?
+
+      SidebarPageTitle.new(title, section, sidebar_page)
+    end
+
+    def lead
+      section = find_section(@page)
+      return section unless section.nil?
+
+      @lead
+    end
+
+    def to_s
+      @title
+    end
+
+    def inspect
+      @title
+    end
+
+    def <=>(other)
+      return -1 if other.nil?
+
+      @title <=> other.to_s
+    end
+
+    private
+
+    def initialize(title, section, page)
+      raise ArgumentError, 'title cannot be nil' if title.nil?
+      raise ArgumentError, 'title must be a String' unless title.is_a? String
+      raise ArgumentError, 'page cannot be nil' if page.nil?
+      raise ArgumentError, 'page must be a SidebarPage' unless page.is_a? SidebarPage
+
+      @page = page
+      @title = title
+      parts = title.split('–')
+      @section = section
+      @lead = parts.first.strip
+      @main = parts.last.strip
+    end
+
+    def find_section(page)
+      # Return the 'section' front matter if it can be found on the current page.
+      return page.title.section unless page.nil? || page.title.nil? || page.title.section.nil? || page.title.section.empty?
+
+      # Recurse upwards to the root (until there is no parent).
+      return find_section(page.parent) unless page.nil? || page.parent.nil?
+
+      nil
+    end
+  end
+end

data/lib/sidebar_parser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'jekyll'
+require_relative 'sidebar_path'
+
+module SwedbankPay
+  # The Sidebar renderer
+  class SidebarParser
+    def initialize(site)
+      raise ArgumentError, 'Site cannot be nil' if site.nil?
+      raise ArgumentError, 'Site must be a Jekyll::Site' unless site.is_a? Jekyll::Site
+
+      @site = site
+    end
+
+    def parse
+      pages = build_pages_hash
+
+      destination = @site.config['destination']
+
+      Dir.glob("#{destination}/**/*.html") do |filename|
+        doc = File.open(filename) { |f| Nokogiri::HTML(f) }
+        path = SidebarPath.new(filename).to_s
+        page = pages[path]
+
+        if page.nil?
+          Jekyll.logger.debug("           Sidebar: No page found for <#{path}>.")
+          next
+        end
+
+        page.doc = doc
+        page.filename = filename
+        page.headers = find_headers(doc)
+        page.sidebar_container = find_sidebar_container(filename, doc)
+      end
+
+      pages
+    end
+
+    private
+
+    def build_pages_hash
+      pages_hash = {}
+
+      @site.pages.each do |jekyll_page|
+        sidebar_page = SidebarPage.new(jekyll_page)
+        pages_hash[sidebar_page.path] = sidebar_page
+      end
+
+      pages_hash
+    end
+
+    def find_headers(doc)
+      headers = []
+
+      doc.xpath('//h2').each do |header|
+        next unless header['id']
+
+        child_markup = header.last_element_child
+        header = {
+          id: header['id'],
+          title: header.content.strip,
+          hash: (child_markup['href']).to_s
+        }
+        headers.push(header)
+      end
+
+      headers
+    end
+
+    def find_sidebar_container(filename, doc)
+      sidebar_containers = doc.xpath('//*[@id="dx-sidebar-main-nav-ul"]')
+
+      unless sidebar_containers.any?
+        Jekyll.logger.debug("           Sidebar: No sidebar container found in #{filename}")
+        return nil
+      end
+
+      sidebar_containers.first
+    end
+  end
+end

data/lib/sidebar_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'sanitized_filename'
+require_relative 'sidebar_page_title'
+
+module SwedbankPay
+  # Represents a page in the Sidebar
+  class SidebarPath
+    attr_reader :parent, :level, :name
+
+    def initialize(path)
+      @segments = segment(path)
+      @path = normalized(path)
+      @name = construct_name
+      @parent = find_parent
+    end
+
+    def to_s
+      @path
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def segment(path)
+      segments = path.sanitized.split('/').reject(&:empty?)
+      @level = segments.length.zero? ? 0 : segments.length - 1
+      segments
+    end
+
+    def normalized(path)
+      return '/' if @segments.empty?
+
+      joined = "/#{@segments.join('/')}"
+
+      # Directory paths should end with '/'.
+      directory?(path) ? "#{joined}/" : joined
+    end
+
+    def directory?(path)
+      path.end_with?('/') || path.end_with?('/index.html')
+    end
+
+    def construct_name
+      return '/' if @path == '/'
+
+      @segments.last
+    end
+
+    def find_parent
+      # If there's no or only one path segment, this is a root page
+      return nil if @segments.empty? || (@segments.length == 1)
+
+      # Return the path minus the last segment as the parent path
+      last = @path.sub(%r{(/#{@segments.last}/?)$}, '')
+      "#{last}/"
+    end
+  end
+end

data/lib/sidebar_renderer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'sidebar_html_builder'
+
+module SwedbankPay
+  # Renders the Sidebar
+  class SidebarRenderer
+    def initialize(tree)
+      raise ArgumentError, 'pages cannot be nil' if tree.nil?
+      raise ArgumentError, 'pages must be an SidebarTreeBuilder' unless tree.is_a? SidebarTreeBuilder
+
+      @tree = tree
+    end
+
+    def enrich_jekyll
+      enrich_jekyll_pages(@tree)
+    end
+
+    def render
+      render_pages(@tree)
+    end
+
+    private
+
+    def enrich_jekyll_pages(pages)
+      return if pages.empty?
+
+      pages.each do |page|
+        page.enrich_jekyll
+
+        enrich_jekyll_pages(page.children)
+      end
+    end
+
+    def render_pages(pages)
+      return if pages.empty?
+
+      pages.each do |page|
+        sidebar_html = render_page(page)
+
+        next if sidebar_html.nil?
+        next if page.sidebar_container.nil?
+
+        page.sidebar_container.inner_html = sidebar_html
+
+        page.save
+
+        render_pages(page.children)
+      end
+    end
+
+    def render_page(page)
+      sidebar_html = nil
+
+      begin
+        builder = SidebarHTMLBuilder.new(@tree)
+        sidebar_html = builder.build(page)
+
+        File.open('_site/sidebar.html', 'w') { |f| f.write(sidebar_html) }
+      rescue StandardError => e
+        name = page.filename || page.name
+        Jekyll.logger.error("           Sidebar: Unable to render sidebar for '#{name}'.")
+        Jekyll.logger.debug("           Sidebar: #{e.message}. #{e.backtrace.inspect}")
+        return nil
+      end
+
+      sidebar_html
+    end
+  end
+end

data/lib/sidebar_text_builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: false
+
+require_relative 'sidebar_page'
+
+module SwedbankPay
+  # Builds a plain text representation of a Sidebar, suitable for a terminal.
+  class SidebarTextBuilder
+    def initialize(page)
+      raise ArgumentError, 'Page must be a SidebarPage' unless page.is_a? SidebarPage
+
+      @page = page
+    end
+
+    def to_s
+      name = @page.name == '/' ? '/' : "/#{@page.name}"
+      title = @page.title.nil? ? '?' : @page.title.main
+      s = "#{indent} #{name}: #{title} (#{@page.coordinate})\n"
+
+      unless @page.children.empty?
+        @page.children.each do |child|
+          s << child.to_s
+        end
+      end
+
+      # Only strip extraneous whitespace at the root page
+      @page.level.zero? ? s.strip : s
+    end
+
+    private
+
+    def indent
+      # Return a special character for the first root page
+      return '┍╾' if (@page.number.nil? || @page.number.zero?) && @page.parent.nil?
+
+      increment = @page.level > 1 ? @page.level + 1 : @page.level
+
+      "┝╾#{'─' * increment}"
+    end
+
+    def todo
+      # This 'todo' method exists to circumvent the following RuboCop error:
+      # lib/sidebar_text_builder.rb:39:97: C: Style/AsciiComments: Use only ascii symbols in comments.
+      "TODO: Add logic to find the very last page regardless of level and have indent it with '┕╾─'"
+    end
+  end
+end

data/lib/sidebar_tree_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: false
+
+require 'forwardable'
+require_relative 'sidebar_page_collection'
+
+module SwedbankPay
+  # Arranges Sidebar pages into a tree
+  class SidebarTreeBuilder
+    include Enumerable
+    extend Forwardable
+    def_delegators :@pages, :each, :length, :empty?, :<<, :[], :count
+
+    def initialize(pages)
+      raise ArgumentError, 'Pages must be a Hash' unless pages.is_a? Hash
+
+      @pages = tree(pages)
+    end
+
+    def to_s
+      stringify
+    end
+
+    def inspect
+      stringify(inspection: true)
+    end
+
+    private
+
+    def stringify(inspection: false)
+      output = "<#{self.class} ##{count}"
+
+      if inspection
+        output << ":\n"
+        @pages.each do |page|
+          output << "#{page}\n"
+        end
+      end
+
+      output << '>'
+      output
+    end
+
+    def tree(pages)
+      tree = []
+      children_of = {}
+      page_number = 0
+
+      sort_by_path_reversed(pages).each do |_, page|
+        children_of[page.path] = [] if children_of[page.path].nil?
+        page.children = children_of[page.path].sort
+
+        if page.parent.nil?
+          # Root pages are pushed directly into the root of the tree
+          page.number = page_number
+          tree.push(page)
+          page_number += 1
+        else
+          children_of[page.parent] = [] if children_of[page.parent].nil?
+          children_of[page.parent].push(page)
+        end
+      end
+
+      # Sort the root pages
+      tree.sort!
+
+      SidebarPageCollection.new(nil, tree)
+    end
+
+    def sort_by_path_reversed(pages)
+      pages.sort_by { |path, _| path }.reverse
+    end
+  end
+end