swedbank-pay-design-guide-jekyll-theme 1.8.1 → 1.9.4

data/lib/sidebar_page.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: false
+
+require 'jekyll'
+require 'nokogiri'
+require_relative 'sidebar_path'
+require_relative 'sidebar_page_title'
+require_relative 'sidebar_page_collection'
+require_relative 'sidebar_text_builder'
+
+module SwedbankPay
+  # Represents a jekyll_page in the Sidebar
+  class SidebarPage
+    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1)
+
+    attr_reader :path, :title, :level, :order, :children, :name, :filename, :doc
+    attr_accessor :headers, :sidebar_container, :number, :parent
+
+    def initialize(jekyll_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
+
+      @filename = jekyll_page.destination('')
+      @jekyll_page = jekyll_page
+      sidebar_path = SidebarPath.new(jekyll_page['url'])
+      @path = sidebar_path.to_s
+      @parent = sidebar_path.parent
+      @level = sidebar_path.level
+      @name = sidebar_path.name
+      @hide_from_sidebar = jekyll_page['hide_from_sidebar'].nil? ? false : jekyll_page['hide_from_sidebar']
+      @title = SidebarPageTitle.parse(jekyll_page, self)
+      @order = menu_order(jekyll_page)
+      @children = SidebarPageCollection.new(self)
+    end
+
+    def active?(current, is_leaf: false)
+      current_path = find_path(current)
+
+      return true if @path == current_path
+
+      # If we're on a leaf node item, such as when rendering the first header
+      # item of a sub-group, its children's active state must be disregarded.
+      unless is_leaf
+        @children.each do |child|
+          return true if child.active?(current_path, is_leaf: is_leaf)
+        end
+      end
+
+      false
+    end
+
+    def hidden?
+      return true if @title.nil?
+      return true if @hide_from_sidebar
+
+      false
+    end
+
+    def hidden_for?(other_page)
+      # The current page should be hidden for the other page unless the
+      # other page is also hidden.
+      hidden = hidden?
+
+      if other_page.nil? || !other_page.is_a?(SidebarPage)
+        Jekyll.logger.debug("           Sidebar: Other page '#{other_page}' is nil or not a SidebarPage")
+        return hidden
+      end
+
+      # If the other page is hidden, the current page should not be hidden
+      # from it.
+      return false if other_page.hidden? && in_same_section_as?(other_page)
+
+      hidden
+    end
+
+    def children=(children)
+      @children = SidebarPageCollection.new(self, children)
+    end
+
+    def to_s
+      SidebarTextBuilder.new(self).to_s
+    end
+
+    def inspect
+      to_s
+    end
+
+    def <=>(other)
+      return -1 if other.nil?
+
+      if @order == FIXNUM_MAX && other.order == FIXNUM_MAX
+        return 0 if @title.nil? && other.title.nil?
+        return -1 if other.title.nil?
+        return 1 if title.nil?
+
+        return @title <=> other.title
+      end
+
+      @order <=> other.order
+    end
+
+    def enrich_jekyll
+      if @title.nil?
+        Jekyll.logger.debug("           Sidebar: No title for #{@name}")
+        return
+      end
+
+      Jekyll.logger.debug("           Sidebar: <#{@path}>.lead_title('#{@title.lead}').main_title('#{@title.main}')")
+
+      @jekyll_page.data['lead_title'] = @title.lead
+      @jekyll_page.data['main_title'] = @title.main
+    end
+
+    def save
+      Jekyll.logger.debug("   Writing Sidebar: #{filename}")
+
+      File.open(@filename, 'w') do |file|
+        html = @doc.to_html(encoding: 'UTF-8')
+        file.write(html)
+      end
+    end
+
+    def children?
+      !children.nil? && children.any?
+    end
+
+    def headers?
+      !headers.nil? && headers.any?
+    end
+
+    def coordinate
+      return @number.to_s if @parent.nil?
+      return @number.to_s unless @parent.respond_to? :coordinate
+
+      "#{@parent.coordinate}.#{@number}"
+    end
+
+    def load
+      @doc = File.open(@filename) { |f| Nokogiri::HTML(f) }
+      @doc
+    end
+
+    private
+
+    def menu_order(jekyll_page)
+      order = jekyll_page['menu_order']
+      return FIXNUM_MAX if order.nil? || order.to_s.empty?
+
+      order.to_i
+    end
+
+    def eq?(path)
+      @path == path
+    end
+
+    def child_of?(path)
+      @path.split('/').length > @level && path.start_with?(@path)
+    end
+
+    def find_path(current)
+      if current.nil?
+        Jekyll.logger.warn('           Sidebar: Nil current_page')
+        return ''
+      end
+
+      return current if current.is_a? String
+      return current.path if current.respond_to?(:path)
+
+      Jekyll.logger.warn("           Sidebar: #{current.class} ('#{current}') does not respond to :path.")
+
+      ''
+    end
+
+    def in_same_section_as?(other_page)
+      # If this or the other page is the root index page, just ignore the
+      # hidden state completely
+      return false if other_page.path == '/' || @path == '/'
+
+      other_page.path.start_with?(@path) || @path.start_with?(other_page.path)
+    end
+  end
+end

data/lib/sidebar_page_collection.rb

@@ -0,0 +1,36 @@
+# 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
+        @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,94 @@
+# 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? && section.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, 'Both title and section cannot be nil' if title.nil? && section.nil?
+      raise ArgumentError, 'page cannot be nil' if page.nil?
+      raise ArgumentError, 'page must be a SidebarPage' unless page.is_a? SidebarPage
+
+      if title.nil?
+        raise ArgumentError, 'section must be a String' unless section.is_a? String
+
+        title = section
+      elsif section.nil?
+        raise ArgumentError, 'title must be a String' unless title.is_a? String
+      end
+
+      @page = page
+      @title = title
+      parts = title.split('–')
+      @section = section
+      @lead = parts.first.strip
+      @main = parts.last.strip
+    end
+
+    def find_section(page)
+      raise ArgumentError, 'page cannot be nil' if page.nil?
+      raise ArgumentError, 'page must be a SidebarPage' unless page.is_a? SidebarPage
+
+      # Return the 'section' front matter if it can be found on the current page.
+      section = section_from_front_matter(page)
+
+      return section unless section.nil?
+
+      # Recurse upwards to the root (until there is no parent).
+      section_from_parent(page)
+    end
+
+    def section_from_front_matter(page)
+      return nil if page.nil? || page.title.nil? || page.title.section.nil? || page.title.section.empty?
+
+      page.title.section
+    end
+
+    def section_from_parent(page)
+      return nil if page.nil? || page.parent.nil?
+
+      find_section(page.parent) unless page.nil? || page.parent.nil?
+    end
+  end
+end

data/lib/sidebar_parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'jekyll'
+require 'jekyll-redirect-from'
+require_relative 'sidebar_path'
+
+module SwedbankPay
+  # The Sidebar renderer
+  class SidebarParser
+    attr_reader :pages
+
+    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
+
+      @pages = convert(site.pages)
+    end
+
+    def parse(tree)
+      raise ArgumentError, 'tree cannot be nil' if tree.nil?
+      raise ArgumentError, 'tree must be a SidebarTreeBuilder' unless tree.is_a? SidebarTreeBuilder
+
+      parse_html(tree)
+    end
+
+    private
+
+    def convert(pages)
+      pages_hash = {}
+
+      pages.each do |jekyll_page|
+        if skippable? jekyll_page
+          Jekyll.logger.debug("           Sidebar: Skipping <#{jekyll_page['url']}>")
+          next
+        end
+
+        sidebar_page = SidebarPage.new(jekyll_page)
+        pages_hash[sidebar_page.path] = sidebar_page
+      end
+
+      pages_hash
+    end
+
+    def parse_html(pages)
+      return if pages.nil? || pages.empty?
+
+      pages.each do |page|
+        page.load
+        page.headers = find_headers(page)
+        page.sidebar_container = find_sidebar_container(page)
+        page.freeze
+
+        parse_html(page.children)
+      end
+
+      pages
+    end
+
+    def find_headers(page)
+      headers = []
+
+      page.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(page)
+      sidebar_containers = page.doc.xpath('//*[@id="dx-sidebar-main-nav-ul"]')
+
+      if sidebar_containers.empty?
+        Jekyll.logger.error("           Sidebar: No sidebar container found in <#{page.filename}>!")
+        return nil
+      end
+
+      sidebar_containers.first
+    end
+
+    def skippable?(jekyll_page)
+      return true if jekyll_page.is_a? JekyllRedirectFrom::RedirectPage
+      return true if jekyll_page.is_a? JekyllRedirectFrom::PageWithoutAFile
+
+      false
+    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