bookwatch 1.0.0

data/lib/bookwatch/subnav/subnav_generator_factory.rb

@@ -0,0 +1,29 @@
+require_relative 'template_creator'
+require_relative 'pdf_config_creator'
+
+module Bookwatch
+  module Subnav
+    class SubnavGeneratorFactory
+      def initialize(fs, output_locations)
+        @fs = fs
+        @output_locations = output_locations
+      end
+
+      def produce(json_generator)
+        SubnavGenerator.new(json_generator, template_creator, pdf_config_creator, output_locations)
+      end
+
+      attr_reader :fs, :output_locations
+
+      private
+
+      def template_creator
+        @template_creator ||= TemplateCreator.new(fs, output_locations)
+      end
+
+      def pdf_config_creator
+        @pdf_config_creator ||= PdfConfigCreator.new(fs, output_locations)
+      end
+    end
+  end
+end

data/lib/bookwatch/subnav/template_creator.rb

@@ -0,0 +1,71 @@
+require 'erb'
+require 'rack/utils'
+
+module Bookwatch
+  module Subnav
+    class TemplateCreator
+      def initialize(fs, output_locations)
+        @fs = fs
+        @output_locations = output_locations
+      end
+
+      def create(navigation_entries, subnav_spec)
+        template_content = fs.read(template_path)
+        links_template = ERB.new(fs.read(subnavs_path.join('_nav-links.erb')))
+
+        populated_nav = ERB.new(template_content).result(LinkHolder.new(navigation_entries, links_template).get_binding)
+
+        fs.write(text: populated_nav, to: subnav_destination(subnav_spec.subnav_name))
+      end
+
+      attr_reader :fs, :output_locations, :html_doc_manipulator
+
+      private
+
+      def subnavs_path
+        output_locations.subnavs_for_layout_dir
+      end
+
+      def filename(name)
+        "#{name}.erb"
+      end
+
+      def template_path
+        subnavs_path.join('_subnav_template.erb')
+      end
+
+      def subnav_destination(name)
+        subnavs_path.join(filename(name))
+      end
+
+      class LinkHolder
+        def initialize(links, template)
+          @links = links
+          @template = template
+        end
+
+        attr_reader :links
+
+        def get_binding
+          binding
+        end
+
+        def render_links(some_links)
+          @template.result(LinkHolder.new(some_links, @template).get_binding)
+        end
+
+        def submenu_class(link)
+          'has_submenu' unless links?(link[:nested_links])
+        end
+
+        def links?(links)
+          (links || []).empty?
+        end
+
+        def escape_html(str)
+          Rack::Utils.escape_html(str)
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/terminal.rb

@@ -0,0 +1,19 @@
+require_relative 'colorizer'
+
+module Bookwatch
+  class Terminal
+    def initialize(colorizer)
+      @colorizer = colorizer
+    end
+
+    def update(user_message)
+      if user_message.error?
+        error_message = @colorizer.colorize(user_message.message, Colorizer::Colors.red)
+        $stderr.puts error_message
+      elsif user_message.warn?
+        warning_message = @colorizer.colorize(user_message.message, Colorizer::Colors.yellow)
+        puts warning_message
+      end
+    end
+  end
+end

data/lib/bookwatch/values/output_locations.rb

@@ -0,0 +1,91 @@
+require_relative '../directory_helpers'
+require_relative '../errors/programmer_mistake'
+
+module Bookwatch
+  class OutputLocations
+    include DirectoryHelperMethods
+
+    def initialize(final_app_dir: nil, context_dir: nil)
+      @final_app_dir = final_app_dir
+      @context_dir = context_dir
+    end
+
+    def final_app_dir
+      Pathname(@final_app_dir)
+    end
+
+    def public_dir
+      final_app_dir.join('public')
+    end
+
+    def build_dir
+      master_dir.join('build/.')
+    end
+
+    def workspace_dir
+      master_dir.join('source')
+    end
+
+    def master_dir
+      output_dir.join('master_middleman')
+    end
+
+    def output_dir
+      context_dir.join(output_dir_name)
+    end
+
+    def preprocessing_home_dir
+      output_dir.join('preprocessing')
+    end
+
+    def cloned_preprocessing_dir
+      preprocessing_home_dir.join('sections')
+    end
+
+    def html_from_preprocessing_dir
+      preprocessing_home_dir.join('html_from_preprocessing')
+    end
+
+    def pdf_from_preprocessing_dir
+      preprocessing_home_dir.join('pdf_from_preprocessing')
+    end
+
+    def formatted_dir
+      preprocessing_home_dir.join('site_generator_ready')
+    end
+
+    def site_generator_home
+      output_dir.join('master_middleman')
+    end
+
+    def source_for_site_generator
+      site_generator_home.join('source')
+    end
+
+    def subnavs_for_layout_dir
+      source_for_site_generator.join('subnavs')
+    end
+
+    def pdf_config_dir
+      context_dir
+    end
+
+    def artifact_dir
+      context_dir.join('artifacts')
+    end
+
+    def pdf_artifact_dir
+      artifact_dir.join('pdfs')
+    end
+
+    private
+
+    def context_dir
+      if @context_dir.nil?
+        raise Errors::ProgrammerMistake.new("You must provide a context_dir to OutputLocations")
+      else
+        Pathname(@context_dir)
+      end
+    end
+  end
+end

data/lib/bookwatch/values/product_info.rb

@@ -0,0 +1,11 @@
+module Bookwatch
+  ProductInfo = Struct.new(
+  :use_local_header,
+    :latest_stable_version,
+    :changelog_href,
+    :local_header_img,
+    :local_header_title
+  ) do
+
+  end
+end

data/lib/bookwatch/values/section.rb

@@ -0,0 +1,58 @@
+require_relative '../errors/programmer_mistake'
+require_relative '../ingest/destination_directory'
+
+module Bookwatch
+  Section = Struct.new(
+    :path_to_repository,
+    :full_name,
+    :desired_directory_name,
+    :subnav_templ,
+    :desired_subnav_name,
+    :preprocessor_config,
+    :at_repo_path,
+    :repo_name,
+    :source_ref,
+    :pdf_output_filename,
+    :product_info) do
+
+    def path_to_repo_dir
+      at_repo_path.nil? ? path_to_repository : path_to_repository.join(at_repo_path)
+    end
+
+    def subnav_template
+      subnav_templ.sub(/^_/, '').sub(/\.erb$/, '') if subnav_templ
+    end
+
+    def destination_directory
+      Ingest::DestinationDirectory.new(full_name, desired_directory_name)
+    end
+
+    def subnav
+      {namespace => subnav_name}
+    end
+
+    def namespace
+      destination_directory.to_s.gsub(%r{[./]}, '_')
+    end
+
+    def subnav_name
+      subnav_template || desired_subnav_name || 'default'
+    end
+
+    def path_to_preprocessor_attribute(attr)
+      path_to_repo_dir.join(preprocessor_config[attr]) if preprocessor_config[attr]
+    rescue NoMethodError => e
+      raise Errors::ProgrammerMistake.new(
+        "path_to_preprocessor_attribute assumes preprocessor_config is available, got nil.\n" +
+          "Original exception:\n\n#{e.inspect}\n\n#{e.backtrace.join("\n")}"
+      )
+    end
+
+    private
+
+    def path_to_repository
+      Pathname(self[:path_to_repository].to_s)
+    end
+
+  end
+end

data/lib/bookwatch/values/subnav_template.rb

@@ -0,0 +1,4 @@
+module Bookwatch
+  SubnavTemplate = Struct.new(:json_links,
+                      :text)
+end

data/lib/bookwatch/values/user_message.rb

@@ -0,0 +1,15 @@
+require 'ostruct'
+
+module Bookwatch
+  UserMessage = Struct.new(:message, :escalation_type) do
+    def error?
+      escalation_type == EscalationType.error
+    end
+
+    def warn?
+      escalation_type == EscalationType.warn
+    end
+  end
+
+  EscalationType = OpenStruct.new(success: 0, error: 1, warn: 2)
+end

data/master_middleman/archive_drop_down_menu.rb

@@ -0,0 +1,50 @@
+module Bookwatch
+  class ArchiveDropDownMenu
+    def initialize(config, current_path: nil)
+      @config = config_with_default(config)
+      @current_path = current_path
+    end
+
+    def title
+      directory_config.first
+    end
+
+    def dropdown_links
+      versions_to_paths.map { |version_path|
+        {version_path.keys.first => "/#{version_path.values.first}"}
+      }
+    end
+
+    def empty?
+      title.nil? && dropdown_links.empty?
+    end
+
+    private
+
+    attr_reader :config, :current_path
+
+    def versions_to_paths
+      directory_config[1..-1]
+    end
+
+    def directory_config
+      config.fetch(directory, config.fetch(root_menu_reference)) || empty_menu
+    end
+
+    def directory
+      File.dirname(current_path)
+    end
+
+    def config_with_default(config)
+      { root_menu_reference => empty_menu }.merge(config || {})
+    end
+
+    def empty_menu
+      [nil]
+    end
+
+    def root_menu_reference
+      '.'
+    end
+  end
+end

data/master_middleman/bookwatch_helpers.rb

@@ -0,0 +1,259 @@
+require 'bookwatch/code_example_reader'
+require 'bookwatch/ingest/cloner_factory'
+require 'bookwatch/ingest/git_accessor'
+require 'bookwatch/local_filesystem_accessor'
+require 'date'
+require_relative 'archive_drop_down_menu'
+require_relative 'quicklinks_renderer'
+
+I18n.enforce_available_locales = false
+
+module Bookwatch
+  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)
+        cloner_factory = Ingest::ClonerFactory.new({out: $stdout},
+                                                   LocalFilesystemAccessor.new,
+                                                   Ingest::GitAccessor.new)
+
+        cloner = cloner_factory.produce(config[:local_repo_dir])
+        code_example_reader = CodeExampleReader.new({out: $stdout},
+                                                    LocalFilesystemAccessor.new)
+        working_copy = cloner.call(source_repo_name: from,
+                                   source_ref: 'master',
+                                   destination_parent_dir: config[:workspace])
+
+        snippet, language = code_example_reader.get_snippet_and_language_at(at, working_copy)
+
+        delimiter = '```'
+
+        snippet.prepend("#{delimiter}#{language}\n").concat("\n#{delimiter}")
+      end
+
+      def elastic_search?
+        !!config[:elastic_search]
+      end
+
+      def yield_for_subnav
+        partial "subnavs/#{subnav_template_name}"
+      end
+
+      def yield_for_archive_drop_down_menu
+        menu = ArchiveDropDownMenu.new(
+          config[:archive_menu],
+          current_path: current_page.path
+        )
+        unless menu.empty?
+          partial 'archive_menus/default', locals: { menu_title: menu.title,
+                                                     dropdown_links: menu.dropdown_links }
+        end
+      end
+
+      def exclude_feedback
+        current_page.add_metadata({page: {feedback_disabled: true}})
+      end
+
+      def yield_for_feedback
+        partial 'layouts/feedback' if config[:feedback_enabled] && !current_page.metadata[:page][:feedback_disabled]
+      end
+
+      def exclude_repo_link
+        current_page.add_metadata({page: {repo_link_disabled: true}})
+      end
+
+      def render_repo_link
+        if config[:repo_link_enabled] && repo_url && !current_page.metadata[:page][:repo_link_disabled]
+          "<a id='repo-link' href='#{repo_url}'>View the source for this page in GitHub</a>"
+        end
+      end
+
+      def mermaid_diagram(&blk)
+        escaped_text = capture(&blk).gsub('-','\-')
+
+        @_out_buf.concat "<div class='mermaid'>#{escaped_text}</div>"
+      end
+
+      def modified_date(default_date: nil)
+        parsed_default_date = Time.parse(default_date).utc if default_date
+
+        date = page_last_modified_date || parsed_default_date
+
+        "Page last updated: <span data-behavior=\"DisplayModifiedDate\" data-modified-date=\"#{date.to_i}000\"></span>" if date
+      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 product_info
+        config[:product_info].fetch(template_key, {})
+      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
+
+      def owners
+        html_resources = sitemap.resources.select { |r| r.path.end_with?('.html') }
+        html_resources.each.with_object({}) { |resource, owners|
+          owners[resource.path] = Array(resource.data['owner'])
+        }
+      end
+
+      def template_key
+        decreasingly_specific_namespaces.detect { |ns|
+          config[:subnav_templates].has_key?(ns)
+        }
+      end
+
+      def body_classes(path=current_path.dup, options={})
+        if path.is_a? Hash
+          options = path
+          path = current_path.dup
+        end
+        basename = File.basename(path)
+        dirname = File.dirname(path).gsub('.', '_')
+        page_classes(File.join(dirname, basename), options)
+      end
+
+      private
+
+      def subnav_template_name
+        if current_path == 'search.html'
+          config[:subnav_templates].values.first
+        else
+          config[:subnav_templates][template_key] || 'default'
+        end
+      end
+
+      def decreasingly_specific_namespaces
+        body_classes(numeric_prefix: numeric_class_prefix).
+          split(' ').reverse.drop(1).
+          map {|ns| ns.sub(/^#{numeric_class_prefix}/, '')}
+      end
+
+      def numeric_class_prefix
+        'NUMERIC_CLASS_PREFIX'
+      end
+
+      def page_last_modified_date
+        git_accessor = Ingest::GitAccessor.new
+
+        current_date = if current_page.data.dita
+          git_accessor.author_date(preprocessing_path(current_page.source_file), dita: true)
+        else
+          git_accessor.author_date(current_page.source_file)
+        end
+
+        current_date.utc if current_date
+      end
+
+      def repo_url
+        nested_dir, filename = parse_out_nested_dir_and_filename
+
+        repo_dir = match_repo_dir(nested_dir)
+        page_repo_config = config[:repo_links][repo_dir]
+
+        if page_repo_config && page_repo_config['ref']
+          org_repo = Pathname(page_repo_config['repo'])
+          ref = Pathname(page_repo_config['ref'])
+          at_path = at_path(page_repo_config)
+          nested_dir = extract_nested_directory(nested_dir, repo_dir)
+
+          "http://github.com/#{org_repo.join(Pathname('tree'), ref, Pathname(nested_dir), at_path, source_file(filename))}"
+        end
+      end
+
+      def match_repo_dir(nested_dir)
+        config[:repo_links].keys
+          .select{ |key| nested_dir.match(/^#{key}/) }
+          .sort_by{ |key| key.length }
+          .last
+      end
+
+      def source_file(filename)
+        fs = LocalFilesystemAccessor.new
+
+        if current_page.data.dita
+          source_filename = "#{filename}.xml"
+
+          if fs.source_file_exists?(Pathname(preprocessing_path(current_page.source_file)).dirname,
+                                             source_filename)
+            source_filename
+          else
+            ''
+          end
+        else
+          "#{filename}.html.md.erb"
+        end
+      end
+
+      def preprocessing_path(current_source_path)
+        root_path, nested_repo_path = current_source_path.split('source')
+
+        root_path.gsub!('/output/master_middleman', '')
+
+        "#{root_path}output/preprocessing/sections#{nested_repo_path}"
+      end
+
+      def parse_out_nested_dir_and_filename
+        current_page.path
+          .match(/\/?(.*?)\/?([^\/]*)\.html$?/)
+          .captures
+      end
+
+      def extract_nested_directory(nested_dir, repo_dir)
+        nested_dir = nested_dir.gsub("#{repo_dir}", '')
+        nested_dir = nested_dir.sub('/', '') if nested_dir[0] == '/'
+
+        nested_dir
+      end
+
+      def at_path(page_repo_config)
+        path = page_repo_config['at_path'] || ""
+
+        Pathname(path)
+      end
+
+      def add_ancestors_of(page, ancestors)
+        if page
+          add_ancestors_of(page.parent, ancestors + [page])
+        else
+          ancestors
+        end
+      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
+    end
+  end
+end
+::Middleman::Extensions.register(:navigation, Bookwatch::Navigation)