bookwatch 1.0.0

data/lib/bookwatch/local_filesystem_accessor.rb

@@ -0,0 +1,122 @@
+require 'find'
+require 'pathname'
+require_relative 'errors/programmer_mistake'
+
+module Bookwatch
+
+  class LocalFilesystemAccessor
+    def file_exist?(path)
+      File.exist?(path)
+    end
+
+    def is_file?(path)
+      File.file?(path)
+    end
+
+    def is_dir?(path)
+      Dir.exists?(path)
+    end
+
+    def write(to: nil, text: nil)
+      make_directory(File.dirname to)
+
+      File.open(to, 'a') do |f|
+        f.write(text)
+      end
+
+      to
+    end
+
+    def overwrite(to: nil, text: nil)
+      File.delete(to) if file_exist?(to)
+      write(to: to, text: text)
+    end
+
+    def read(path)
+      File.read(path)
+    end
+
+    def empty_directory(path)
+      FileUtils.rm_rf(File.join(path, '.'))
+    end
+
+    def remove_directory(path)
+      FileUtils.rm_rf(path)
+    end
+
+    def make_directory(path)
+      FileUtils.mkdir_p(path)
+    end
+
+    def copy(src, dest)
+      make_directory(dest)
+      FileUtils.cp_r src, dest
+    end
+
+    def copy_and_rename(src, dest)
+      make_directory(Pathname(dest).dirname)
+      FileUtils.cp_r src, dest
+    end
+
+    def copy_contents(src, dest)
+      raise Errors::ProgrammerMistake.new("The method copy_contents cannot copy the contents of the directory '#{src}' because it was not found.") unless Dir.exists?(src)
+      copy "#{src}/.", dest
+    end
+
+    def copy_including_intermediate_dirs(file, root, dest)
+      path_within_destination = relative_path_from(root, file)
+      extended_dest = File.dirname(File.join dest, path_within_destination)
+      copy file, extended_dest
+    end
+
+    def link_creating_intermediate_dirs(src, dst)
+      FileUtils.mkdir_p(File.dirname(dst))
+      File.symlink(src, dst)
+    end
+
+    def rename_file(path, new_name)
+      new_path = File.expand_path File.join path, '..', new_name
+      File.rename(path, new_path)
+    end
+
+    def find_files_with_ext(ext, path)
+      all_files = find_files_recursively(path)
+      matching_files = all_files.select {|p| p.to_s.match(/\.#{ext}/) }
+      matching_files.map(&:to_s)
+    end
+
+    def relative_path_from(src, target)
+      target_path = Pathname(File.absolute_path target)
+      relative_path = target_path.relative_path_from(Pathname(File.absolute_path src))
+      relative_path.to_s
+    end
+
+    def find_files_recursively(from)
+      `find -L #{from} -type f`.
+        lines.
+        map(&:chomp).
+        map(&Pathname.method(:new)).
+        reject {|p| p.to_s.match %r{/\.}}.
+        reject(&:directory?)
+    end
+
+    def find_files_extension_agnostically(pattern, directory='.')
+      extensionless_pattern = File.join(File.dirname(pattern), File.basename(pattern).split('.').first)
+
+      `find -L #{directory} -path '*/#{extensionless_pattern}.*' -type f`.
+        lines.
+        map(&:chomp).
+        map(&Pathname.method(:new))
+    end
+
+    def source_file_exists?(directory, path_to_file)
+      path = Pathname(path_to_file.split('/').last)
+      source_file_found = false
+
+      Pathname(directory).ascend do |dir|
+        source_file_found = true if dir.entries.any? { |entry| entry == path }
+      end
+      source_file_found
+    end
+  end
+end

data/lib/bookwatch/middleman_runner.rb

@@ -0,0 +1,48 @@
+require 'middleman-core'
+require 'middleman-core/cli'
+require 'middleman-core/profiling'
+require 'yaml'
+
+module Bookwatch
+  class MiddlemanRunner
+    def initialize(fs, sheller)
+      @fs = fs
+      @sheller = sheller
+    end
+
+    def run(command,
+            streams: nil,
+            output_locations: nil,
+            config: nil,
+            local_repo_dir: nil,
+            subnavs: nil,
+            product_info: nil)
+      streams[:out].puts "\nRunning middleman...\n\n"
+      Dir.chdir(output_locations.master_dir) do
+        config = {
+          archive_menu: config.archive_menu,
+          production_host: config.public_host,
+          subnav_templates: subnavs,
+          template_variables: config.template_variables,
+          local_repo_dir: local_repo_dir,
+          workspace: output_locations.workspace_dir,
+          feedback_enabled: config.feedback_enabled,
+          repo_link_enabled: config.repo_link_enabled,
+          repo_links: config.repo_links,
+          product_info: product_info,
+          elastic_search: config.elastic_search?
+        }
+
+        fs.write(to: "bookwatch_config.yml", text: YAML.dump(config))
+        sheller.run_command({'MM_ROOT' => output_locations.master_dir.to_s},
+                            "middleman #{command}",
+                            streams)
+      end
+    end
+
+    private
+
+    attr_reader :streams, :fs, :sheller
+
+  end
+end

data/lib/bookwatch/postprocessing/link_checker.rb

@@ -0,0 +1,125 @@
+require 'nokogiri'
+require_relative '../css_link_checker'
+require_relative 'redirection'
+
+module Bookwatch
+  module Postprocessing
+    class LinkChecker
+      def initialize(fs, root_path, output_streams)
+        @fs = fs
+        @root_path = root_path
+        @output_streams = output_streams
+        @broken_link_count = 0
+
+        @convert_to_relative = %r{\A.*#{root_path.to_s}/public}
+        @default_link_exclusions = %r{\A(?:https?://|javascript:|mailto:)}
+        @excluded_pages = %r{\A/(?:404\.html|subnavs|javascripts|stylesheets|style_guide)}
+      end
+
+      def check!(link_exclusions = /(?!.*)/)
+        @output_streams[:out].puts "\nChecking for broken links..."
+        @redirects = Redirection.new(@fs, File.join(@root_path, 'redirects.rb'))
+        load_page_links
+
+        report_broken_links!(link_exclusions)
+        report_orphaned_pages!
+
+        if has_errors?
+          err "\nFound #{@broken_link_count} broken links!"
+        else
+          out "\nNo broken links!"
+        end
+      end
+
+      def has_errors?
+        @broken_link_count > 0
+      end
+
+      private
+
+      def report_broken_links!(link_exclusions)
+        @page_links.each do |page, links|
+          links.each do |link|
+            next if skip?(link, link_exclusions)
+
+            absolute_link, fragment = normalize_link(link, page)
+
+            if !page_exists?(absolute_link) && !file_exists?(absolute_link)
+              @broken_link_count += 1
+              err "#{page} => #{absolute_link}#{fragment ? "##{fragment}" : ''}"
+            end
+          end
+        end
+
+        broken_css_links = Dir.chdir(@root_path) { CssLinkChecker.new.broken_links_in_all_stylesheets }
+        broken_css_links.reject! { |link| link_exclusions.match(link) }
+
+        @broken_link_count += broken_css_links.size
+        broken_css_links.each do |link|
+          err link
+        end
+      end
+
+      def report_orphaned_pages!
+        linked_pages = @page_links.map do |page, links|
+          links.map do |link|
+            normalize_link(link, page)[0]
+          end
+        end.flatten.uniq
+
+        orphaned_pages = @page_links.keys.reject { |page| page == '/index.html' || linked_pages.include?(page) }
+        if orphaned_pages.size > 0
+          err "\nOrphaned pages"
+          orphaned_pages.each do |page|
+            err "No links to => #{page}"
+          end
+        end
+      end
+
+      def skip?(link_path, link_exclusions)
+        @default_link_exclusions.match(link_path) || link_path.match(link_exclusions)
+      end
+
+      def page_exists?(link)
+        @page_links.has_key?(link) || @redirects.redirected?(link)
+      end
+
+      def normalize_link(link, page)
+        return [page, link.sub(/\A#/, '')] if link[0] == '#'
+
+        absolute_link = link[0] == '/' ? link : File.expand_path(link, File.dirname(page))
+        absolute_link.split('#')
+      end
+
+      def file_exists?(link)
+        full_path = File.join(@root_path, 'public', link)
+        @fs.is_file?(full_path) || (@fs.is_dir?(full_path) && @fs.is_file?(File.join(full_path, 'index.html')))
+      end
+
+      def load_page_links
+        files = @fs.find_files_with_ext('html', File.join(@root_path, 'public'))
+
+        @page_links = files.each.with_object({}) do |file_path, links|
+          public_path = file_path.sub(@convert_to_relative, '')
+
+          if !@excluded_pages.match(public_path)
+            html = Nokogiri::HTML(@fs.read(file_path))
+
+            links[public_path] = [
+              html.css('a[href]').map { |link| link['href'] },
+              html.css('img').map { |image| image['src'] }
+            ].flatten
+          end
+        end
+      end
+
+      def out(str)
+        @output_streams[:out].puts(str)
+      end
+
+      def err(str)
+        @output_streams[:err].puts(str)
+      end
+    end
+  end
+end

data/lib/bookwatch/postprocessing/redirection.rb

@@ -0,0 +1,38 @@
+module Bookwatch
+  module Postprocessing
+    class Redirection
+      def initialize(fs, file_path)
+        @redirect_regexes = {}
+        @redirect_strings = {}
+        load!(fs, file_path)
+      end
+
+      def redirected?(url)
+        @redirect_strings.has_key?(url) ||
+          @redirect_regexes.keys.detect {|regex| regex.match(url)}
+      end
+
+      private
+
+      def load!(fs, file_path)
+        if fs.is_file?(file_path)
+          contents = fs.read(file_path)
+          instance_eval contents
+        end
+      end
+
+      def r301(source, dest, options={})
+        return if options.has_key?(:if)
+
+        case source
+        when Regexp
+          @redirect_regexes[source] = dest
+        when String
+          @redirect_strings[source] = dest
+        end
+      end
+      alias r302 r301
+      alias rewrite r301
+    end
+  end
+end

data/lib/bookwatch/preprocessing/dita_html_preprocessor.rb

@@ -0,0 +1,91 @@
+require_relative '../values/subnav_template'
+require_relative '../../../lib/bookwatch/subnav/navigation_entries_from_html_toc'
+
+module Bookwatch
+  module Preprocessing
+    class DitaHTMLPreprocessor
+      DitaToHtmlLibraryFailure = Class.new(RuntimeError)
+
+      ACCEPTED_IMAGE_FORMATS = %w(png jpeg jpg svg gif bmp tif tiff eps)
+
+      def initialize(fs, subnav_gen_factory, dita_formatter, command_creator, sheller)
+        @fs = fs
+        @subnav_gen_factory = subnav_gen_factory
+        @dita_formatter = dita_formatter
+        @command_creator = command_creator
+        @sheller = sheller
+      end
+
+      def applicable_to?(section)
+        section.subnav_template.include?('dita_subnav') if section.subnav_template
+      end
+
+      def preprocess(sections, output_locations, options: {}, output_streams: nil, **_)
+        @output_locations = output_locations
+
+        sections.each do |section|
+          if section.path_to_preprocessor_attribute('ditamap_location')
+            convert_dita_files(section,
+                               command_creator,
+                               options[:dita_flags],
+                               section_html_dir(section),
+                               sheller,
+                               output_streams)
+
+            subnav_generator.generate(section)
+          end
+
+          dita_formatter.format_html(section_html_dir(section), formatted_dir(section))
+          copy_images(section.path_to_repo_dir, formatted_dir(section))
+          fs.copy_contents(formatted_dir(section), source_for_site_gen_dir(section))
+        end
+      end
+
+      private
+
+      attr_reader :fs, :subnav_gen_factory, :dita_formatter, :command_creator, :sheller, :output_locations
+
+      def section_html_dir(section)
+        output_locations.html_from_preprocessing_dir.join(section.destination_directory)
+      end
+
+      def formatted_dir(section)
+        output_locations.formatted_dir.join(section.destination_directory)
+      end
+
+      def source_for_site_gen_dir(section)
+        output_locations.source_for_site_generator.join(section.destination_directory)
+      end
+
+      def convert_dita_files(section, command_creator, options, section_html_dir, sheller, output_streams)
+        command = command_creator.convert_to_html_command(
+          section,
+          dita_flags: options,
+          write_to: section_html_dir
+        )
+        status = sheller.run_command(command, output_streams.to_h)
+        unless status.success?
+          raise DitaToHtmlLibraryFailure.new 'The DITA-to-HTML conversion failed. ' +
+                'Please check that you have specified the path to your DITA-OT library in the ENV, ' +
+                'that your DITA-specific keys/values in config.yml are set, ' +
+                'and that your DITA toolkit is correctly configured.'
+        end
+      end
+
+      def copy_images(src, dest)
+        image_paths = ACCEPTED_IMAGE_FORMATS.map do |format|
+          fs.find_files_with_ext(format, src)
+        end.flatten
+
+        image_paths.each do |image_path|
+          fs.copy_including_intermediate_dirs(image_path, src, dest)
+        end
+      end
+
+
+      def subnav_generator
+        @subnav_generator ||= subnav_gen_factory.produce(Subnav::NavigationEntriesFromHtmlToc.new(fs))
+      end
+    end
+  end
+end

data/lib/bookwatch/preprocessing/dita_pdf_preprocessor.rb

@@ -0,0 +1,48 @@
+module Bookwatch
+  module Preprocessing
+    class DitaPDFPreprocessor
+      DitaToPDFLibraryFailure = Class.new(RuntimeError)
+
+      def initialize(fs, command_creator, sheller)
+        @fs = fs
+        @command_creator = command_creator
+        @sheller = sheller
+      end
+
+      def applicable_to?(section)
+        !!section.pdf_output_filename
+      end
+
+      def preprocess(sections, output_locations, options: {}, output_streams: nil, **_)
+        sections.each do |section|
+          command = command_creator.convert_to_pdf_command(
+            section,
+            dita_flags: options[:dita_flags],
+            write_to: output_locations.pdf_from_preprocessing_dir
+          )
+          status = sheller.run_command(command, output_streams.to_h)
+
+          if status.success?
+            pdf_path = most_recent_pdf(output_locations.pdf_from_preprocessing_dir)
+            pdf_destination = output_locations.pdf_artifact_dir.join(section.pdf_output_filename)
+            fs.copy_and_rename(pdf_path, pdf_destination)
+          else
+            raise DitaToPDFLibraryFailure.new 'The DITA-to-PDF conversion failed. ' +
+              'Please check that you have specified the path to your DITA-OT library in the ENV, ' +
+              'that your DITA-specific keys/values in config.yml are set, ' +
+              'and that your DITA toolkit is correctly configured.'
+          end
+        end
+      end
+
+      def most_recent_pdf(dir_path)
+        pdfs_by_modified_date = Dir.glob(dir_path + '**/*.pdf').sort_by{ |f| File.mtime(f) }
+        pdfs_by_modified_date.last
+      end
+
+      private
+
+      attr_reader :command_creator, :sheller, :fs
+    end
+  end
+end