bookwatch 1.0.0

data/lib/bookwatch/config/imprint/configuration.rb

@@ -0,0 +1,24 @@
+require_relative '../configuration'
+
+module Bookwatch
+  module Config
+    module Imprint
+      class Configuration < Config::Configuration
+        class << self
+          def parse(input_config)
+            section_configs = to_section_configs(pdf_sections(input_config))
+            parse_sections(input_config, section_configs)
+          end
+
+          private
+
+          def pdf_sections(input_config)
+            (input_config['pdf_sections'] || []).map { |pdf_section|
+              DitaConfigGenerator.new(pdf_section).to_hash
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/product_config.rb

@@ -0,0 +1,34 @@
+module Bookwatch
+  module Config
+    class ProductConfig
+      def initialize(config)
+        @config = config
+      end
+
+      def id
+        config['id']
+      end
+
+      def pdf_config
+        config['pdf_config']
+      end
+
+      def subnav_root
+        config['subnav_root']
+      end
+
+      def valid?
+        (CONFIG_REQUIRED_KEYS - config.keys).empty?
+      end
+
+      CONFIG_REQUIRED_KEYS = %w(id)
+
+      alias_method :subnav_name, :id
+
+      private
+
+      attr_reader :config
+    end
+  end
+end
+

data/lib/bookwatch/config/section_config.rb

@@ -0,0 +1,85 @@
+require_relative '../ingest/repo_identifier'
+
+module Bookwatch
+  module Config
+    class SectionConfig
+      def initialize(config)
+        @config = config
+      end
+
+      def subnav_template
+        config['subnav_template']
+      end
+
+      def product_id
+        config['product_id']
+      end
+
+      def desired_directory_name
+        config['directory']
+      end
+
+      def pdf_output_filename
+        config['output_filename']
+      end
+
+      def repo_name
+        repo['name']
+      end
+
+      def repo_url
+        Ingest::RepoIdentifier.new(repo['name'])
+      end
+
+      def repo_ref
+        repo['ref'] || 'master'
+      end
+
+      def at_repo_path
+        repo['at_path']
+      end
+
+      def no_docs?
+        config.fetch('no_docs', false)
+      end
+
+      def dependent_sections
+        @sections ||= (config['dependent_sections'] || []).map do |dep_section|
+          SectionConfig.new(dep_section)
+        end
+      end
+
+      def preprocessor_config
+        config.fetch('preprocessor_config', {})
+      end
+
+      def ==(other)
+        config == other.instance_variable_get(:@config)
+      end
+
+      def merge(other_section_config)
+        SectionConfig.new(config.merge(other_section_config.instance_variable_get(:@config)))
+      end
+
+      def inspect
+        config.inspect
+      end
+
+      alias_method :subnav_name, :product_id
+
+      def product_info
+        return {} if config['product_info'].nil?
+        config['product_info']
+      end
+
+      private
+
+      def repo
+        config.fetch('repository', {})
+      end
+
+      attr_reader :config
+    end
+  end
+end
+

data/lib/bookwatch/config/validator.rb

@@ -0,0 +1,33 @@
+require_relative 'checkers/duplicate_section_name_checker'
+require_relative 'checkers/archive_menu_checker'
+require_relative 'checkers/required_keys_checker'
+require_relative 'checkers/repository_name_presence_checker'
+require_relative 'checkers/ditamap_presence_checker'
+require_relative 'checkers/section_presence_checker'
+require_relative 'checkers/products_checker'
+
+module Bookwatch
+  module Config
+    class Validator
+      def initialize(file_system_accessor)
+        @file_system_accessor = file_system_accessor
+      end
+
+      def exceptions(config)
+        exceptions = [
+          Checkers::RequiredKeysChecker.new,
+          Checkers::DuplicateSectionNameChecker.new,
+          Checkers::RepositoryNamePresenceChecker.new,
+          Checkers::SectionPresenceChecker.new,
+          Checkers::DitamapPresenceChecker.new,
+          Checkers::ArchiveMenuChecker.new(@file_system_accessor),
+          Checkers::ProductsChecker.new
+        ].map do |checker|
+          checker.check(config)
+        end
+
+        exceptions.compact
+      end
+    end
+  end
+end

data/lib/bookwatch/config/yaml_loader.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+module Bookwatch
+  module Config
+    FileNotFoundError = Class.new(RuntimeError)
+    InvalidSyntaxError = Class.new(RuntimeError)
+
+    class YAMLLoader
+      def load(path)
+        if File.exist?(path)
+          config(path)
+        else
+          raise FileNotFoundError.new, "YAML"
+        end
+      rescue Psych::SyntaxError => e
+        raise InvalidSyntaxError.new e
+      end
+
+      def load_key(path, key)
+        if File.exist?(path)
+          config(path)[key]
+        end
+      rescue Psych::SyntaxError => e
+        raise InvalidSyntaxError.new e
+      end
+
+      private
+
+      def config(path)
+        YAML.load_file(path) || {}
+      end
+    end
+  end
+end

data/lib/bookwatch/css_link_checker.rb

@@ -0,0 +1,67 @@
+require 'css_parser'
+
+module Bookwatch
+  class CssLinkChecker
+    def broken_links_in_all_stylesheets
+      localized_links_in_stylesheets.reject { |link| target_exists?(link) }
+    end
+
+    private
+
+    def localized_links_in_stylesheets
+      links_in_stylesheets = []
+      Dir.glob('**/*.css').each { |stylesheet| links_in_stylesheets.concat localized_links_from(stylesheet) }
+
+      links_in_stylesheets
+    end
+
+    def localized_links_from(stylesheet)
+      localized_uris = []
+      css = CssParser::Parser.new
+      css.load_uri! stylesheet
+
+      css.each_selector do |s, declaration, sp|
+        contents_of_url_value = /url\((.*?)\)/
+        file_url = declaration.match contents_of_url_value
+        localized_uris << "#{URI(stylesheet).path} => #{file_url[1]}" if file_url
+      end
+
+      localized_uris
+    end
+
+    def target_exists?(localized_identifier)
+      dirs, link = strip_location(localized_identifier)
+      link.gsub!(/'|"/, '')
+
+      data_uri      = /^['"]?data:image\//
+      remote_uri    = /^['"]?https?:\/\//
+      absolute_uri  = /^['"]?\//
+      relative_uri  = //
+
+      case link
+        when data_uri then true
+        when remote_uri then http_reachable?(link)
+        when absolute_uri then File.exists?(File.join('.', 'public', path_info(link)))
+        when relative_uri then
+          dirs = dirs.split('/')[0...-1]
+          computed_uri = File.expand_path(File.join dirs, path_info(link))
+          File.exists?(computed_uri)
+      end
+    end
+
+    def path_info(link)
+      link.sub(/[?#].+\z/, '')
+    end
+
+    def strip_location(id)
+      dirs, filepath = id.split('=> ')
+      [dirs, filepath]
+    end
+
+    def http_reachable?(link)
+      Net::HTTP.get_response(URI(link)).code == '200'
+    rescue SocketError => e
+      return false
+    end
+  end
+end

data/lib/bookwatch/directory_helpers.rb

@@ -0,0 +1,15 @@
+module Bookwatch
+  module DirectoryHelperMethods
+
+    private
+
+    def output_dir_name
+      'output'
+    end
+
+    def source_dir_name
+      'source'
+    end
+
+  end
+end

data/lib/bookwatch/dita_command_creator.rb

@@ -0,0 +1,95 @@
+module Bookwatch
+  class DitaCommandCreator
+    MissingDitaOTFlagValue = Class.new(RuntimeError)
+
+    def initialize(path_to_dita_ot_library)
+      @path_to_dita_ot_library = path_to_dita_ot_library
+    end
+
+    def convert_to_pdf_command(dita_section, dita_flags: nil, write_to: nil)
+      "export CLASSPATH=#{classpath}; " +
+      "ant -f #{path_to_dita_ot_library} " +
+      unduplicated_flags(
+        write_to: write_to,
+        dita_flags: dita_flags,
+        ditamap_path: dita_section.path_to_preprocessor_attribute('ditamap_location'),
+        ditaval_path: dita_section.path_to_preprocessor_attribute('ditaval_location'),
+        default_transtype: 'pdf2'
+      )
+    end
+
+    def convert_to_html_command(dita_section, dita_flags: nil, write_to: nil)
+      "export CLASSPATH=#{classpath}; " +
+      "ant -f #{path_to_dita_ot_library} " +
+        unduplicated_flags(
+          write_to: write_to,
+          dita_flags: dita_flags,
+          ditamap_path: dita_section.path_to_preprocessor_attribute('ditamap_location'),
+          ditaval_path: dita_section.path_to_preprocessor_attribute('ditaval_location'),
+          default_transtype: 'tocjs'
+      )
+    end
+
+    private
+
+    def unduplicated_flags(write_to: nil, ditamap_path: nil, ditaval_path: nil, dita_flags: nil, default_transtype: nil)
+      arg_flags = {
+          'output.dir' => write_to,
+          'args.input' => ditamap_path,
+      }.merge(filter(ditaval_path))
+      all_flags = arg_flags.merge(base_flags(default_transtype: default_transtype).merge(optional_flags(dita_flags)))
+      format(all_flags)
+    end
+
+    def filter(ditaval_path)
+      ditaval_path ? { 'args.filter' => ditaval_path } : {}
+    end
+
+    def base_flags(default_transtype: nil)
+      {
+          'basedir' => '/',
+          'transtype' => default_transtype,
+          'dita.temp.dir' => '/tmp/bookwatch_dita',
+          'generate.copy.outer' => '2',
+          'outer.control' => 'warn'
+      }
+    end
+
+    def optional_flags(flags_str)
+      flags = flags_str ? flags_str.split(" ") : []
+      {}.tap do |h|
+        flags.each do |f|
+          k,v = f.split('=')
+          h[k] = v
+          raise MissingDitaOTFlagValue.new("The DITA-flag '#{k}' that you passed is missing a value. Please pass your DITA option in the format '#{k}=<value>'.") unless v
+        end
+      end
+    end
+
+    def format(flags)
+      flags.inject("") do |res, f|
+        k,v = f
+        res + "-D#{k}='#{stripped_flag_value v}' "
+      end
+    end
+
+    def stripped_flag_value(v)
+      v.to_s.gsub(/['|"]/, "")
+    end
+
+    def classpath
+      "#{path_to_dita_ot_library}/lib/xercesImpl.jar:" +
+      "#{path_to_dita_ot_library}/lib/xml-apis.jar:" +
+      "#{path_to_dita_ot_library}/lib/resolver.jar:" +
+      "#{path_to_dita_ot_library}/lib/commons-codec-1.4.jar:" +
+      "#{path_to_dita_ot_library}/lib/icu4j.jar:" +
+      "#{path_to_dita_ot_library}/lib/saxon/saxon9-dom.jar:" +
+      "#{path_to_dita_ot_library}/lib/saxon/saxon9.jar:target/classes:" +
+      "#{path_to_dita_ot_library}:" +
+      "#{path_to_dita_ot_library}/lib/:" +
+      "#{path_to_dita_ot_library}/lib/dost.jar"
+    end
+
+    attr_reader :path_to_dita_ot_library
+  end
+end

data/lib/bookwatch/dita_html_for_middleman_formatter.rb

@@ -0,0 +1,45 @@
+module Bookwatch
+
+  class DitaHtmlForMiddlemanFormatter
+    def initialize(file_system_accessor, html_document_manipulator)
+      @file_system_accessor = file_system_accessor
+      @html_document_manipulator = html_document_manipulator
+    end
+
+    def format_html(src, dest)
+      all_files_with_ext = file_system_accessor.find_files_with_ext('html', src)
+
+      all_files_with_ext.map do |filepath|
+        file_text = file_system_accessor.read(filepath)
+
+        file_title_text = html_document_manipulator.read_html_in_tag(document: file_text,
+                                                                     tag: 'title')
+
+        file_body_text = html_document_manipulator.read_html_in_tag(document: file_text,
+                                                                    tag: 'body')
+
+        cleansed_body_text = revert_to_erb(file_body_text)
+
+        relative_path_to_file = file_system_accessor.relative_path_from(src, filepath)
+        new_filepath = File.join dest, "#{relative_path_to_file}.erb"
+
+        output_text = frontmatter(file_title_text) + cleansed_body_text
+
+        file_system_accessor.write(to: new_filepath, text: output_text)
+      end
+    end
+
+    private
+
+    attr_reader :file_system_accessor, :html_document_manipulator
+
+    def frontmatter(title)
+      sanitized_title = title.gsub('"', '\"')
+      "---\ntitle: \"#{sanitized_title}\"\ndita: true\n---\n"
+    end
+
+    def revert_to_erb(text)
+      text.gsub('&lt;%', '<%').gsub('%&gt;', '%>').gsub('&lt;\%', '&lt;%')
+    end
+  end
+end

data/lib/bookwatch/errors/programmer_mistake.rb

@@ -0,0 +1,5 @@
+module Bookwatch
+  module Errors
+    ProgrammerMistake = Class.new(RuntimeError)
+  end
+end