bookwatch 1.0.0

data/lib/bookwatch/preprocessing/link_to_site_gen_dir.rb

@@ -0,0 +1,39 @@
+require_relative '../subnav/subnav_generator'
+require_relative '../subnav/navigation_entries_from_markdown_root'
+
+module Bookwatch
+  module Preprocessing
+    class LinkToSiteGenDir
+      def initialize(filesystem, subnav_generator_factory)
+        @filesystem = filesystem
+        @subnav_generator_factory = subnav_generator_factory
+      end
+
+      def applicable_to?(section)
+        filesystem.file_exist?(section.path_to_repo_dir)
+      end
+
+      def preprocess(sections, output_locations, config: nil, options: {}, **_)
+        sections.each do |section|
+          filesystem.link_creating_intermediate_dirs(
+            section.path_to_repo_dir,
+            output_locations.source_for_site_generator.join(section.destination_directory)
+          )
+        end
+
+        generator = subnav_generator(options[:require_valid_subnav_links])
+        config.products.each do |product|
+          generator.generate(product)
+        end
+      end
+
+      private
+
+      def subnav_generator(require_valid_subnav_links)
+        @subnav_generator ||= subnav_generator_factory.produce(Subnav::NavigationEntriesFromMarkdownRoot.new(filesystem, require_valid_subnav_links))
+      end
+
+      attr_reader :filesystem, :subnav_generator_factory
+    end
+  end
+end

data/lib/bookwatch/preprocessing/preprocessor.rb

@@ -0,0 +1,26 @@
+module Bookwatch
+  module Preprocessing
+    class Preprocessor
+      class NullProcess
+        def preprocess(*)
+        end
+      end
+
+      def initialize(*processes)
+        @processes = processes
+      end
+
+      def preprocess(sections, *args)
+        sections.group_by { |section|
+          processes.detect ->{ NullProcess.new } { |process| process.applicable_to?(section) }
+        }.each do |process, grouped_sections|
+          process.preprocess(grouped_sections, *args)
+        end
+      end
+
+      private
+
+      attr_reader :processes
+    end
+  end
+end

data/lib/bookwatch/server_director.rb

@@ -0,0 +1,30 @@
+require 'puma'
+
+module Bookwatch
+  class ServerDirector
+    def initialize(app: nil, directory: nil, port: 41722)
+      @app = app
+      @directory = directory
+      @port = port
+    end
+
+    def use_server
+      Dir.chdir(@directory) do
+        events = Puma::Events.new $stdout, $stderr
+        server = Puma::Server.new app, events
+        server.add_tcp_listener "localhost", @port
+        server.run
+        begin
+          result = yield @port
+        ensure
+          server.stop(true)
+        end
+        result
+      end
+    end
+
+    private
+
+    attr_reader :app
+  end
+end

data/lib/bookwatch/sheller.rb

@@ -0,0 +1,52 @@
+require 'open3'
+
+module Bookwatch
+  class Sheller
+    ShelloutFailure = Class.new(RuntimeError)
+
+    class DevNull
+      def puts(_)
+      end
+
+      def <<(_)
+      end
+    end
+
+    def run_command(*command)
+      out, err =
+        if Hash === command.last
+          command.last.values_at(:out, :err)
+        else
+          [DevNull.new, DevNull.new]
+        end
+
+      env_vars, executable =
+        if Hash === command.first
+          command[0..1]
+        else
+          [{}, command[0]]
+        end
+
+      exit_status = nil
+      Open3.popen3(env_vars, executable) do |stdin, stdout, stderr, wait_thr|
+        t = Thread.new do
+          stdout.each do |line|
+            out.puts(line)
+          end
+        end
+        stderr.each do |line|
+          err.puts(line)
+        end
+        t.join
+        exit_status = wait_thr.value
+      end
+      exit_status
+    end
+
+    def get_stdout(command)
+      out = StringIO.new
+      run_command(command, out: out)
+      out.tap(&:rewind).read.chomp
+    end
+  end
+end

data/lib/bookwatch/streams/colorized_stream.rb

@@ -0,0 +1,25 @@
+require_relative '../colorizer'
+
+module Bookwatch
+  module Streams
+    class ColorizedStream
+      def initialize(color, stream)
+        @color = color
+        @stream = stream
+        @colorizer = Colorizer.new
+      end
+
+      def puts(line)
+        stream.puts(colorizer.colorize(line, color))
+      end
+
+      def <<(text)
+        stream << colorizer.colorize(text, color)
+      end
+
+      private
+
+      attr_reader :color, :colorizer, :stream
+    end
+  end
+end

data/lib/bookwatch/streams/filter_stream.rb

@@ -0,0 +1,22 @@
+module Bookwatch
+  module Streams
+    class FilterStream
+      def initialize(matcher_regex, stream)
+        @matcher_regex = matcher_regex
+        @stream = stream
+      end
+
+      def puts(line)
+        stream.puts(line.gsub("\n", '')) if line.match(matcher_regex)
+      end
+
+      def <<(line)
+        stream << line.gsub("\n", '') if line.match(matcher_regex)
+      end
+
+      private
+
+      attr_reader :matcher_regex, :stream
+    end
+  end
+end

data/lib/bookwatch/subnav/navigation_entries_from_html_toc.rb

@@ -0,0 +1,59 @@
+require 'nokogiri'
+require 'active_support/all'
+
+module Bookwatch
+  module Subnav
+    class NavigationEntriesFromHtmlToc
+      def initialize(fs)
+        @fs = fs
+        @external_link_check = %r{\Ahttps?://}
+      end
+
+      def get_links(section, output_locations)
+        @section, @output_locations = section, output_locations
+
+        doc = parse_toc_file
+        set_anchor_values(doc.css('a'))
+
+        gather_urls_and_texts(doc.css('body > ul'))
+      end
+
+      private
+
+      attr_reader :fs, :section, :output_locations
+
+      def parse_toc_file
+        html = fs.read(
+          File.join(
+            output_locations.html_from_preprocessing_dir,
+            section.destination_directory,
+            'index.html')
+        )
+        Nokogiri::XML(html)
+      end
+
+      def set_anchor_values(anchors)
+        anchors.each do |anchor|
+          unless @external_link_check.match(anchor['href'])
+            anchor['href'] = "/#{section.destination_directory}/#{anchor['href']}"
+          end
+        end
+      end
+
+      def gather_urls_and_texts(base_node)
+        top_level_li = base_node.css("> li")
+        top_level_li.map do |li|
+          anchor = li.css('a')[0]
+          href = anchor['href']
+          text = anchor.inner_text
+          ul = li.css('> ul')
+          if ul.size > 0
+            {url: href, text: text, nested_links: gather_urls_and_texts(ul)}
+          else
+            {url: href, text: text}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/subnav/navigation_entries_from_markdown_root.rb

@@ -0,0 +1,116 @@
+require 'json'
+require 'nokogiri'
+require 'redcarpet'
+
+module Bookwatch
+  module Subnav
+    class NavigationEntriesFromMarkdownRoot
+      SubnavDuplicateLinkError = Class.new(RuntimeError)
+      SubnavBrokenLinkError = Class.new(RuntimeError)
+      SubnavRootMissingError = Class.new(RuntimeError)
+
+      def initialize(fs, require_valid_subnav_links)
+        @fs = fs
+        @require_valid_subnav_links = require_valid_subnav_links
+        @renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML.new)
+      end
+
+      def get_links(product_config, output_locations)
+        @source_for_site_gen = output_locations.source_for_site_generator
+        @config = product_config
+
+        root = absolute_source_from_path(Pathname(config.subnav_root))
+
+        if root.nil?
+          if @require_valid_subnav_links
+            raise SubnavRootMissingError.new('Subnav root not found at: ' + config.subnav_root)
+          else
+            return []
+          end
+        end
+
+        @parsed_files = {Pathname(root) => '(root)'}
+
+        gather_urls_and_texts(root)
+      end
+
+      attr_reader :fs, :source_for_site_gen, :renderer, :config
+
+      private
+
+      def get_html(md)
+        Nokogiri::HTML(renderer.render(md))
+      end
+
+      def absolute_source_from_path(path)
+        full_sources = fs.find_files_extension_agnostically(path, source_for_site_gen)
+        full_sources.first
+      end
+
+      # href: ./cat/index.html
+      # expanded href: my/cat/index.html
+      # full source: my/cat/index.html.md.erb
+      def gather_urls_and_texts(source)
+        toc_md = fs.read(source)
+        base_node = get_html(toc_md).css('html')
+
+        nav_items(base_node).map do |element|
+          href = element['href']
+          expanded_href = (source.dirname + href).relative_path_from(source_for_site_gen)
+          next_source = absolute_source_from_path(expanded_href)
+          nested_links = {}
+
+          no_children = false
+          no_children ||= validate_no_broken_link(expanded_href, next_source, source)
+          no_children ||= validate_no_duplicate_link(expanded_href, next_source, source)
+
+          unless no_children
+            @parsed_files[next_source] = source
+            nested_urls_and_texts = gather_urls_and_texts(next_source)
+            nested_links.merge!(nested_links: nested_urls_and_texts) unless nested_urls_and_texts.empty?
+          end
+
+          {url: '/' + expanded_href.to_s, text: element.inner_text}.merge(nested_links)
+        end
+      end
+
+      def validate_no_duplicate_link(expanded_href, next_source, source)
+        if @parsed_files.has_key?(next_source)
+          if @require_valid_subnav_links
+            raise SubnavDuplicateLinkError.new(<<-ERROR)
+)
+Duplicate link found in subnav for product_id: #{config.id}
+
+Link: #{expanded_href}
+Original file: #{@parsed_files[next_source]}
+Current file: #{source}
+            ERROR
+          else
+            no_children = true
+          end
+        end
+        no_children
+      end
+
+      def validate_no_broken_link(expanded_href, next_source, source)
+        unless next_source
+          if @require_valid_subnav_links
+            raise SubnavBrokenLinkError.new(<<-ERROR)
+Broken link found in subnav for product_id: #{config.id}
+
+Link: #{expanded_href}
+Source file: #{source}
+            ERROR
+          else
+            no_children = true
+          end
+        end
+        no_children
+      end
+
+      def nav_items(base_node)
+        base_node.css('a.subnav')
+      end
+    end
+  end
+end

data/lib/bookwatch/subnav/pdf_config_creator.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+
+module Bookwatch
+  module Subnav
+    class PdfConfigCreator
+      def initialize(fs, output_locations)
+        @fs = fs
+        @output_locations = output_locations
+      end
+
+      def create(navigation_entries, subnav_config)
+        @links = format_links(navigation_entries)
+
+        fs.overwrite(to: output_locations.pdf_config_dir.join(subnav_config.pdf_config),
+                     text: config_content)
+      end
+
+      attr_reader :fs, :output_locations
+
+      private
+
+      def props_location(filename)
+        output_locations.subnavs_for_layout_dir.join(filename)
+      end
+
+      def format_links(links)
+        links.map{|item| item[:url] }.compact.map{|link| link.sub(/^\//, '')}
+      end
+
+      def config_content
+        config_keys.inject({}) do |hash, key|
+          hash[key] = content_for(key)
+          hash
+        end.to_yaml
+      end
+
+      def config_keys
+        %w{copyright_notice header executable pages}
+      end
+
+      def content_for(key)
+        key == 'pages' ? @links : default_content
+      end
+
+      def default_content
+        'REPLACE ME'
+      end
+    end
+  end
+end

data/lib/bookwatch/subnav/subnav_generator.rb

@@ -0,0 +1,28 @@
+module Bookwatch
+  module Subnav
+    class SubnavGenerator
+      def initialize(navigation_entries_parser, template_creator, pdf_config_creator, output_locations)
+        @navigation_entries_parser = navigation_entries_parser
+        @template_creator = template_creator
+        @pdf_config_creator = pdf_config_creator
+        @output_locations = output_locations
+      end
+
+      def generate(subnav_spec)
+        navigation_entries = navigation_entries_parser.get_links(subnav_spec, output_locations)
+        template_creator.create(navigation_entries, subnav_spec)
+        pdf_config_creator.create(navigation_entries, subnav_spec) if pdf?(subnav_spec)
+      end
+
+      attr_reader :navigation_entries_parser, :template_creator, :pdf_config_creator
+
+      private
+
+      attr_reader :output_locations
+
+      def pdf?(subnav_spec)
+        subnav_spec.respond_to?(:pdf_config) && subnav_spec.pdf_config
+      end
+    end
+  end
+end