bookbindery 1.0.0

data/lib/bookbinder/sitemap_generator.rb

@@ -0,0 +1,19 @@
+require 'nokogiri'
+
+module Bookbinder
+  class SitemapGenerator
+    def generate(links, sitemap_file)
+      builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.urlset('xmlns' => 'http://www.sitemaps.org/schemas/sitemap/0.9') {
+          links.each do |link|
+            xml.url {
+              xml.loc link
+              xml.changefreq 'daily'
+            }
+          end
+        }
+      end
+      File.write(sitemap_file, builder.to_xml)
+    end
+  end
+end

data/lib/bookbinder/spider.rb

@@ -0,0 +1,91 @@
+require 'anemone'
+require 'pty'
+require_relative 'css_link_checker'
+require_relative 'sieve'
+require_relative 'stabilimentum'
+require_relative 'sitemap_generator'
+
+module Bookbinder
+  class Spider
+    def initialize(logger, app_dir: nil)
+      @logger = logger
+      @app_dir = app_dir || raise('Spiders must be initialized with an app directory.')
+      @broken_links = []
+    end
+
+    def generate_sitemap(target_host, port)
+      temp_host = "localhost:#{port}"
+
+      sieve = Sieve.new domain: "http://#{temp_host}"
+      links = crawl_from "http://#{temp_host}/index.html", sieve
+      @broken_links, working_links = links
+
+      announce_broken_links @broken_links
+
+      write_sitemap(target_host, temp_host, working_links)
+      working_links
+    end
+
+    def has_broken_links?
+      @broken_links.any? { |link| !link.include?('#') } if @broken_links
+    end
+
+    def self.prepend_location(location, url)
+      "#{URI(location).path} => #{url}"
+    end
+
+    private
+
+    def write_sitemap(host, port, working_links)
+      sitemap_file = File.join(@app_dir, 'public', 'sitemap.xml')
+      sitemap_links = substitute_hostname(host, port, working_links)
+      SitemapGenerator.new.generate(sitemap_links, sitemap_file)
+    end
+
+    def announce_broken_links(broken_links)
+      if broken_links.any?
+        @logger.error "\nFound #{broken_links.count} broken links!"
+
+        broken_links.each do |link|
+          if link.include?('#')
+            @logger.warn(link)
+          else
+            @logger.notify(link)
+          end
+        end
+
+        @logger.error "\nFound #{broken_links.count} broken links!"
+      else
+        @logger.success "\nNo broken links!"
+      end
+    end
+
+    def crawl_from(url, sieve)
+      broken_links = []
+      sitemap = [url]
+      2.times do |i|
+        is_first_pass = (i==0)
+
+        Anemone.crawl(url) do |anemone|
+          dont_visit_fragments(anemone)
+          anemone.on_every_page do |page|
+            broken, working = sieve.links_from Stabilimentum.new(page), is_first_pass
+            broken_links.concat broken
+            sitemap.concat working
+          end
+        end
+      end
+
+      broken_links.concat Dir.chdir(@app_dir) { CssLinkChecker.new.broken_links_in_all_stylesheets }
+      [broken_links.compact.uniq, sitemap.compact.uniq]
+    end
+
+    def dont_visit_fragments(anemone)
+      anemone.focus_crawl { |page| page.links.reject { |link| link.to_s.match(/%23/) } }
+    end
+
+    def substitute_hostname(target_host, temp_host, links)
+      links.map { |l| l.gsub(/#{Regexp.escape(temp_host)}/, target_host) }
+    end
+  end
+end

data/lib/bookbinder/stabilimentum.rb

@@ -0,0 +1,59 @@
+module Bookbinder
+  class Spider
+    class Stabilimentum # Decorates a piece of the web.
+      FudgedUri = Struct.new(:path, :fragment, :to_s)
+
+      def initialize(page)
+        @page = page
+      end
+
+      def referer
+        @page.referer
+      end
+
+      def not_found?
+        @page.not_found?
+      end
+
+      def url
+        @page.url
+      end
+
+      def has_target_for?(uri)
+        id_selector = uri.fragment
+        name_selector = "[name=#{uri.fragment}]"
+
+        @page.doc.css("##{id_selector}").any? || @page.doc.css(name_selector).any?
+      rescue Nokogiri::CSS::SyntaxError
+        false
+      end
+
+      def fragment_identifiers(targeting_locally: false)
+        if targeting_locally
+          fragment_anchor_uris.select { |uri| uri.path.empty? }
+        else
+          fragment_anchor_uris.reject { |uri| uri.path.empty? }
+        end
+      end
+
+      private
+
+      def fragment_anchor_uris
+        anchors = @page.doc ? @page.doc.css('a') : []
+        anchors.map { |a| convert_to_uri(a) }.select { |u| u.fragment }
+      end
+
+      def convert_to_uri(anchor)
+        URI anchor['href'].to_s
+      rescue URI::InvalidURIError
+        create_fudged_uri(anchor['href'])
+      end
+
+      def create_fudged_uri(target)
+        path = target.split('#')[0]
+        fragment = target.include?('#') ? '#' + target.split('#')[1] : nil
+        FudgedUri.new(path, fragment, target)
+      end
+    end
+  end
+end

data/lib/bookbinder/usage_messenger.rb

@@ -0,0 +1,33 @@
+module Bookbinder
+  class UsageMessenger
+
+    def construct_for commands, flags
+      log_usage_header + "\n" + flag_usage_messages(flags) + command_usage_messages(commands)
+    end
+
+    private
+
+    def flag_usage_messages(flags)
+      flag_usage_messages = ""
+      flags.each { |f| flag_usage_messages += " \t#{f.usage}\n" }
+      flag_usage_messages
+    end
+
+    def command_usage_messages(commands)
+      flag_command_messages = ""
+      commands.each do |command_class|
+        flag_command_messages += " \t#{command_class.usage}\n"
+      end
+      flag_command_messages
+    end
+
+    def log_usage_header
+      <<TEXT
+
+  \e[1;39;49mDocumentation\e[0m: https://github.com/pivotal-cf/docs-bookbinder
+
+  \e[1;39;49mUsage\e[0m: bookbinder <command|flag> [args]
+TEXT
+    end
+  end
+end

data/lib/bookbinder/yaml_loader.rb

@@ -0,0 +1,22 @@
+module Bookbinder
+
+  FileNotFoundError = Class.new(RuntimeError)
+  InvalidSyntaxError = Class.new(RuntimeError)
+
+  class YAMLLoader
+    def load(path)
+      unless File.exist? path
+        raise FileNotFoundError.new, "YAML"
+      end
+
+      begin
+        YAML.load_file(path)
+      rescue Psych::SyntaxError => e
+        raise InvalidSyntaxError.new e
+      end
+
+    end
+  end
+
+end
+

data/master_middleman/bookbinder_helpers.rb

@@ -0,0 +1,133 @@
+require 'date'
+# mostly from https://github.com/multiscan/middleman-navigation but modified slightly
+require_relative 'quicklinks_renderer'
+
+I18n.enforce_available_locales = false
+
+class ArchiveMenuTemplateNotFound < StandardError;
+end
+
+class ArchiveConfigFormatError < StandardError;
+end
+
+module Bookbinder
+  module Navigation
+    class << self
+      def registered(app)
+        app.helpers HelperMethods
+      end
+
+      alias :included :registered
+    end
+
+    module HelperMethods
+
+      def yield_for_code_snippet(from: nil, at: nil)
+        example = CodeExample.get_instance(bookbinder_logger, section_hash: {'repository' => {'name' => from}}, local_repo_dir: config[:local_repo_dir], git_accessor: config[:git_accessor])
+        snippet, language = example.get_snippet_and_language_at(at)
+        delimiter = '```'
+
+        snippet.prepend("#{delimiter}#{language}\n").concat("\n#{delimiter}")
+      end
+
+      def yield_for_subnav
+        if index_subnav
+          template = current_page.data.index_subnav
+        else
+          namespaces = decreasingly_specific_namespaces
+          template = namespaces.map do |namespace|
+            config[:subnav_templates][namespace]
+          end.compact.pop || 'default'
+        end
+        partial "subnavs/#{template}"
+      end
+
+      def yield_for_archive_drop_down_menu
+        if config.respond_to?(:archive_menu)
+          title = config[:archive_menu].first
+          links = config[:archive_menu][1..-1]
+
+          new_links_based_from_root = links.map do |link|
+            link_from_root = link.dup
+            link_from_root.map do |k, v|
+              link_from_root[k] = "/#{v}"
+            end
+            link_from_root
+          end
+
+          partial 'archive_menus/default', locals: { menu_title: title, dropdown_links: new_links_based_from_root }
+        end
+      end
+
+      def breadcrumbs
+        page_chain = add_ancestors_of(current_page, [])
+        breadcrumbs = page_chain.map do |page|
+          make_breadcrumb(page, page == current_page)
+        end.compact
+        return if breadcrumbs.size < 2
+        return content_tag :ul, breadcrumbs.reverse.join(' '), class: 'breadcrumbs'
+      end
+
+      def vars
+        OpenStruct.new config[:template_variables]
+      end
+
+      def modified_date(format=nil)
+        current_file_in_repo = current_path.dup.gsub(File.basename(current_path), File.basename(current_page.source_file))
+        current_section = get_section_or_book_for(current_file_in_repo)
+        modified_time = current_section.get_modification_date_for(file: current_file_in_repo, full_path: current_page.source_file)
+        (format.nil? ? modified_time : modified_time.strftime(format))
+      end
+
+      def quick_links
+        page_src = File.read(current_page.source_file)
+        quicklinks_renderer = QuicklinksRenderer.new(vars)
+        Redcarpet::Markdown.new(quicklinks_renderer).render(page_src)
+      end
+
+      private
+
+      def get_section_or_book_for(path)
+        sections = config[:sections]
+        book = config[:book]
+
+        raise "Book or Selections are incorrectly specified for Middleman." if book.nil? || sections.nil?
+
+        current_section = nil
+        sections.each { |section| current_section = section if File.dirname(current_path).match(/^#{section.directory}/) }
+
+        return book if current_section.nil?
+        return current_section
+      end
+
+      def index_subnav
+        return true if current_page.data.index_subnav
+      end
+
+      def decreasingly_specific_namespaces
+        page_classes.split(' ')[0...-1].reverse
+      end
+
+      def add_ancestors_of(page, ancestors)
+        return ancestors if !page
+        add_ancestors_of(page.parent, ancestors << page)
+      end
+
+      def make_breadcrumb(page, is_current_page)
+        return nil unless (text = page.data.breadcrumb || page.data.title)
+        if is_current_page
+          css_class = 'active'
+          link = content_tag :span, text
+        else
+          link = link_to(text, '/' + page.path)
+        end
+        content_tag :li, link, :class => css_class
+      end
+
+      def bookbinder_logger
+        BookbinderLogger.new
+      end
+    end
+  end
+end
+::Middleman::Extensions.register(:navigation, Bookbinder::Navigation)

data/master_middleman/config.rb

@@ -0,0 +1,23 @@
+require 'bookbinder_helpers'
+require 'submodule_aware_assets'
+
+set :markdown_engine, :redcarpet
+set :markdown, :layout_engine => :erb,
+               :tables => true,
+               :autolink => true,
+               :smartypants => true,
+               :fenced_code_blocks => true
+
+set :css_dir, 'stylesheets'
+
+set :js_dir, 'javascripts'
+
+set :images_dir, 'images'
+
+set :relative_links, true
+
+activate :submodule_aware_assets
+
+activate :navigation
+
+activate :syntax

data/master_middleman/quicklinks_renderer.rb

@@ -0,0 +1,78 @@
+require 'redcarpet'
+
+class QuicklinksRenderer < Redcarpet::Render::Base
+  class BadHeadingLevelError < StandardError; end
+
+  attr_reader :vars
+
+  def initialize(template_variables)
+    super()
+    @vars = template_variables
+  end
+
+  def doc_header
+    @items = []
+    @items[1] = document.css('ul').first
+    nil
+  end
+
+  def doc_footer
+    document.css('.quick-links').to_html if any_headers?
+  end
+
+  def header(text, header_level)
+    return unless [2, 3].include?(header_level)
+    return unless anchor_for(text)
+
+    li = Nokogiri::XML::Node.new('li', document)
+    li.add_child anchor_for(text)
+    last_list_of_level(header_level-1).add_child(li)
+    @items[header_level] = li
+    nil
+  rescue BadHeadingLevelError => e
+    raise BadHeadingLevelError.new "The header \"#{text}\", which is at level #{e.message} has no higher-level headers occuring before it."
+  end
+
+  private
+
+  def any_headers?
+    @items[2]
+  end
+
+  def anchor_for(text)
+    text = ERB.new(text).result(binding)
+    doc = Nokogiri::HTML(text)
+    target_anchor = doc.css('a').first
+    return unless target_anchor && target_anchor['id']
+
+    anchor = Nokogiri::XML::Node.new('a', document)
+    anchor['href'] = "##{target_anchor['id']}"
+    anchor.content = doc.text.strip
+    anchor
+  end
+
+  def last_list_of_level(n)
+    item = @items[n]
+    raise BadHeadingLevelError.new("#{n+1}") unless item
+    return item if item.name == 'ul'
+
+    item.add_child('<ul>') unless item.css('ul').any?
+    @items[n] = item.css('ul').first
+  end
+
+  def document
+    builder.doc
+  end
+
+  def builder
+    @builder ||= Nokogiri::HTML::Builder.new(&base_quicklinks_doc)
+  end
+
+  def base_quicklinks_doc
+    Proc.new do |html|
+      html.div(class: 'quick-links') {
+        html.ul
+      }
+    end
+  end
+end