swedbank-pay-design-guide-jekyll-theme 1.6.1.pre.PullRequest0137.pre.0064 → 1.9.0

data/lib/sidebar_html_builder.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: false
+
+require_relative 'sidebar_page'
+
+module SwedbankPay
+  # The builder of HTML for the Sidebar
+  class SidebarHTMLBuilder
+    def initialize(tree)
+      @tree = tree
+    end
+
+    def build(current_page)
+      raise ArgumentError, 'current_page cannot be nil' if current_page.nil?
+      raise ArgumentError, "#{current_page.class} is not a #{SidebarPage}" unless current_page.is_a? SidebarPage
+
+      build_markup(@tree, current_page)
+    end
+
+    private
+
+    def build_markup(pages, current_page)
+      return '' if pages.empty?
+
+      current_path = current_path(current_page)
+      markup = ''
+
+      pages.each do |page|
+        next if page.ignore?
+
+        sub_items_markup = sub_items_markup(page, current_path)
+        markup << item_markup(page, current_path, page.level, sub_items_markup)
+      end
+
+      markup
+    end
+
+    def current_path(current_page)
+      if current_page.nil?
+        Jekyll.logger.warn('           Sidebar: Nil current_page')
+        return ''
+      end
+
+      return current_page if current_page.is_a? String
+      return current_page.path if current_page.respond_to?(:path)
+
+      Jekyll.logger.warn("           Sidebar: #{current_page.class} ('#{current_page}') does not respond to :path.")
+
+      ''
+    end
+
+    def item_markup(page, current_path, level, sub_items_markup)
+      title_markup = title_markup(page, level)
+      item_class = item_class(page, current_path, level)
+      group_heading_class = group_heading_class(level)
+
+      "<li class=\"#{item_class}\">
+        <div class=\"#{group_heading_class}\">
+          <i class=\"material-icons\">arrow_right</i>
+          #{title_markup}
+        </div>
+        #{sub_items_markup}
+      </li>"
+    end
+
+    def item_class(page, current_path, level)
+      active = active?(page, current_path, level)
+      item_class = group_class(level)
+      item_class += ' active' if active
+      item_class
+    end
+
+    def group_class(level)
+      level.zero? ? 'nav-group' : 'nav-subgroup'
+    end
+
+    def group_heading_class(level)
+      group_class = group_class(level)
+      "#{group_class}-heading"
+    end
+
+    def title_markup(page, level)
+      section_title = section_title(page)
+      return "<span>#{section_title}</span>" if level.zero?
+
+      item_title = item_title(page)
+      "<a href=\"#{page.path}\">#{item_title}</a>"
+    end
+
+    def sub_items_markup(page, current_path)
+      headers_markup = headers_markup(page, current_path)
+      child_markup = build_markup(page.children, current_path)
+
+      return '' if headers_markup.empty? && child_markup.empty?
+
+      "<ul class=\"nav-ul\">
+        #{headers_markup}
+        #{child_markup}
+      </ul>"
+    end
+
+    def headers_markup(page, current_path)
+      # If there's no page headers, only return a leaf item for the page itself.
+      return leaf_markup(page.path, page.title.item, page.level) unless page.headers?
+
+      # If there's no children, only return the headers as leaf node items.
+      return page.headers.map { |h| header_markup(page, h) }.join('') if page.children.empty?
+
+      headers_markup = page.headers.map { |h| header_markup(page, h) }.join('')
+      headers_markup = "<ul class=\"nav-ul\">#{headers_markup}</ul>"
+
+      item_markup(page, current_path, page.level + 1, headers_markup)
+    end
+
+    def header_markup(page, header)
+      hash = header[:hash]
+      subtitle = header[:title]
+      href = "#{page.path}#{hash}"
+      leaf_markup(href, subtitle)
+    end
+
+    def leaf_markup(href, title, level = 0)
+      leaf_class = level.positive? ? 'nav-leaf nav-subgroup-leaf' : 'nav-leaf'
+      "<li class=\"#{leaf_class}\"><a href=\"#{href}\">#{title}</a></li>"
+    end
+
+    def active?(page, current_path, level)
+      level.zero? ? page.active?(current_path) : page.path == current_path
+    end
+
+    def section_title(page)
+      return page.title.section unless page.title.section.nil?
+      return page.parent.title.to_s unless page.parent.nil? || page.parent.title.nil?
+
+      ''
+    end
+
+    def item_title(page)
+      page.title.item
+    end
+  end
+end

data/lib/sidebar_page.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: false
+
+require 'jekyll'
+require_relative 'sidebar_path'
+require_relative 'sidebar_page_title'
+require_relative 'sidebar_page_collection'
+require_relative 'sidebar_text_builder'
+
+module SwedbankPay
+  # Represents a page in the Sidebar
+  class SidebarPage
+    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1)
+
+    attr_reader :path, :title, :level, :order, :children, :name
+    attr_accessor :headers, :filename, :doc, :sidebar_container, :number, :parent
+
+    def initialize(page)
+      raise ArgumentError, 'Page must be a Jekyll::Page' unless page.is_a? Jekyll::Page
+
+      sidebar_path = SidebarPath.new(page['url'])
+      @path = sidebar_path.to_s
+      @parent = sidebar_path.parent
+      @level = sidebar_path.level
+      @name = sidebar_path.name
+      @hide_from_sidebar = page['hide_from_sidebar'].nil? ? false : page['hide_from_sidebar']
+      @title = page_title(page)
+      @order = menu_order(page)
+      @children = SidebarPageCollection.new(self)
+    end
+
+    def active?(current_path)
+      return true if @path == current_path
+
+      @children.each do |child|
+        return true if child.active?(current_path)
+      end
+
+      false
+    end
+
+    def ignore?
+      return true if @title.nil?
+      return true if @hide_from_sidebar
+
+      false
+    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 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 headers?
+      !headers.nil? && headers.any?
+    end
+
+    def coordinate
+      return @number.to_s if @parent.nil?
+
+      "#{@parent.coordinate}.#{@number}"
+    end
+
+    private
+
+    def page_title(page)
+      title = page['title']
+      return nil if title.nil?
+
+      SidebarPageTitle.new(title)
+    end
+
+    def menu_order(page)
+      order = 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
+  end
+end

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,29 @@
+# frozen_string_literal: true
+
+module SwedbankPay
+  # Represents the title of a SidebarPage
+  class SidebarPageTitle
+    attr_reader :section, :item
+
+    def initialize(title)
+      @title = title
+      parts = title.split('–')
+      @section = parts.first.strip
+      @item = parts.last.strip
+    end
+
+    def to_s
+      @title
+    end
+
+    def inspect
+      @title
+    end
+
+    def <=>(other)
+      return -1 if other.nil?
+
+      @title <=> other.to_s
+    end
+  end
+end

data/lib/sidebar_parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'sidebar_path'
+
+module SwedbankPay
+  # The Sidebar renderer
+  class SidebarParser
+    def initialize(site)
+      @site = site
+    end
+
+    def parse(pages)
+      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]
+
+        raise ArgumentError, "No page found for '#{path}'." if page.nil?
+
+        page.doc = doc
+        page.filename = filename
+        page.headers = find_headers(doc)
+        page.sidebar_container = find_sidebar_container(filename, doc)
+      end
+
+      pages
+    end
+
+    private
+
+    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