bookwatch 1.0.0

data/lib/bookwatch/config/checkers/archive_menu_checker.rb

@@ -0,0 +1,29 @@
+module Bookwatch
+  module Config
+    module Checkers
+      class ArchiveMenuChecker
+        MissingArchiveMenuPartialError = Class.new(RuntimeError)
+        ArchiveMenuNotDefinedError = Class.new(RuntimeError)
+        EmptyArchiveItemsError = Class.new(RuntimeError)
+
+        def initialize(file_system_accessor)
+          @file_system_accessor = file_system_accessor
+        end
+
+        def check(config)
+          partial_location = './master_middleman/source/archive_menus/_default.erb'
+          if config.archive_menu && config.archive_menu.include?(nil)
+            EmptyArchiveItemsError.new 'Did you forget to add a value to the archive_menu?'
+          elsif config.archive_menu && !file_system_accessor.file_exist?(partial_location)
+            MissingArchiveMenuPartialError.new "You must provide a template partial named at #{partial_location}"
+          end
+        end
+
+        private
+
+        attr_reader :file_system_accessor
+
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/ditamap_presence_checker.rb

@@ -0,0 +1,27 @@
+module Bookwatch
+  module Config
+    module Checkers
+      class DitamapPresenceChecker
+        DitamapLocationError = Class.new(RuntimeError)
+
+        def check(config)
+          if any_sections_missing_ditamaps?(config.sections)
+            DitamapLocationError.new(
+              "You must have a 'ditamap_location' for each key in dita_sections."
+            )
+          end
+        end
+
+        private
+
+        def any_sections_missing_ditamaps?(sections)
+          sections.any? do |s|
+            if s.preprocessor_config.has_key?('ditamap_location')
+              s.preprocessor_config['ditamap_location'].nil? || s.preprocessor_config['ditamap_location'].empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/duplicate_section_name_checker.rb

@@ -0,0 +1,33 @@
+require_relative '../../ingest/destination_directory'
+
+module Bookwatch
+  module Config
+    module Checkers
+      class DuplicateSectionNameChecker
+        DuplicateSectionNameError = Class.new(RuntimeError)
+
+        def check(config)
+          if duplicate_section_names?(config)
+            DuplicateSectionNameError.new error_message
+          end
+        end
+
+        private
+
+        def duplicate_section_names?(config)
+          directory_names = config.sections.map {|section|
+            Ingest::DestinationDirectory.new(section.repo_name,
+                                             section.desired_directory_name)
+          }
+          directory_names.length != directory_names.uniq.length
+        end
+
+        def error_message
+          <<-ERROR
+    Duplicate repository names are not allowed.
+          ERROR
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/products_checker.rb

@@ -0,0 +1,34 @@
+module Bookwatch
+  module Config
+    module Checkers
+      class ProductsChecker
+        MissingProductsKeyError = Class.new(RuntimeError)
+        MissingProductIdError = Class.new(RuntimeError)
+
+        def check(config)
+          @config = config
+
+          if section_product_ids.count > 0
+            if config.products.empty?
+              MissingProductsKeyError.new('You must specify at least one product under the products key in config.yml')
+            elsif missing_products.count != 0
+              MissingProductIdError.new("Your config.yml is missing required product id under the products key. Required product ids are #{missing_products.join(", ")}.")
+            end
+          end
+        end
+
+        attr_reader :config
+
+        private
+
+        def missing_products
+          section_product_ids - config.products.map(&:id)
+        end
+
+        def section_product_ids
+          config.sections.map(&:product_id).compact.uniq
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/repository_name_presence_checker.rb

@@ -0,0 +1,34 @@
+module Bookwatch
+  module Config
+    module Checkers
+      class RepositoryNamePresenceChecker
+        MissingRepositoryNameError = Class.new(RuntimeError)
+
+        def check(config)
+          failures = config.sections.reject do |section|
+            section.repo_name
+          end
+
+          if failures.empty?
+            nil
+          else
+            MissingRepositoryNameError.new error_message
+          end
+        end
+
+        private
+
+        def error_message
+          <<-ERROR
+    Cannot locate a specific section.
+    All sections must provide the section 'name' key under the 'repository' key:
+
+    sections:
+      - repository:
+          name: 'your-org/your-repo'
+          ERROR
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/required_keys_checker.rb

@@ -0,0 +1,18 @@
+require_relative '../configuration'
+
+module Bookwatch
+  module Config
+    module Checkers
+      class RequiredKeysChecker
+        MissingRequiredKeyError = Class.new(RuntimeError)
+
+        def check(config)
+          missing_keys = Config::Configuration::CONFIG_REQUIRED_KEYS.reject { |key| config.has_option?(key) }
+          if missing_keys.any?
+            MissingRequiredKeyError.new("Your config.yml is missing required key(s). Required keys are #{missing_keys.join(", ")}.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/checkers/section_presence_checker.rb

@@ -0,0 +1,15 @@
+module Bookwatch
+  module Config
+    module Checkers
+      class SectionPresenceChecker
+        NoSectionsError = Class.new(RuntimeError)
+
+        def check(config)
+          if config.sections.none?
+            NoSectionsError.new('No sections found in your config.yml. Add sections under the appropriate key(s) and try again.')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/config/configuration.rb

@@ -0,0 +1,119 @@
+require_relative '../../../lib/bookwatch/config/dita_config_generator'
+require_relative '../ingest/destination_directory'
+require_relative '../ingest/repo_identifier'
+require_relative 'section_config'
+require_relative 'product_config'
+
+module Bookwatch
+  module Config
+    class Configuration
+      class << self
+        def parse(input_config)
+          section_configs = to_section_configs(combined_sections(input_config))
+          parse_sections(input_config, section_configs)
+        end
+
+        protected
+
+        def parse_sections(input_config, section_configs)
+          new(symbolize_keys(input_config).
+              merge(expand_repo_identifiers(input_config)).
+              merge(sections: section_configs))
+        end
+
+        def symbolize_keys(h)
+          h.reduce({}) {|acc, (k, v)| acc.merge(k.to_sym => v) }
+        end
+
+        def expand_repo_identifiers(input_config)
+          input_config.select {|k, _| k.match(/_repo$/)}.
+            reduce({}) {|h, (k, v)| h.merge(:"#{k}_url" => Ingest::RepoIdentifier.new(v))}
+        end
+
+        def to_section_configs sections
+          sections.map { |section| Config::SectionConfig.new(section) }
+        end
+
+        private
+
+        def combined_sections(input_config)
+          regular_sections(input_config) + dita_sections(input_config)
+        end
+
+        def regular_sections(input_config)
+          input_config['sections'] || []
+        end
+
+        def dita_sections(input_config)
+          (input_config['dita_sections'] || []).map { |dita_section|
+            DitaConfigGenerator.new(dita_section).to_hash
+          }
+        end
+      end
+
+      def initialize(config)
+        @config = config
+        @products = assemble_products || []
+      end
+
+      CONFIG_REQUIRED_KEYS = %w(book_repo public_host)
+      CONFIG_OPTIONAL_KEYS = %w(archive_menu book_repo_url cred_repo cred_repo_url repo_link_enabled repo_links feedback_enabled layout_repo layout_repo_ref layout_repo_url sections)
+
+      CONFIG_REQUIRED_KEYS.each do |method_name|
+        define_method(method_name) do
+          config.fetch(method_name.to_sym)
+        end
+      end
+
+      CONFIG_OPTIONAL_KEYS.each do |method_name|
+        define_method(method_name) do
+          config[method_name.to_sym]
+        end
+      end
+
+      def broken_link_exclusions
+        config.fetch(:broken_link_exclusions, /(?!.*)/)
+      end
+
+      def template_variables
+        config.fetch(:template_variables, {})
+      end
+
+      def merge(other_configuration)
+        Configuration.new(config.merge(other_configuration.instance_variable_get(:@config)))
+      end
+
+      def merge_sections(incoming_sections)
+        merge(Configuration.new(sections: sections + incoming_sections))
+      end
+
+      def has_option?(key)
+        !!config[key.to_sym]
+      end
+
+      def elastic_search?
+        config.fetch(:elastic_search, false)
+      end
+
+      def ==(o)
+        o.class == self.class && o.instance_variable_get(:@config) == @config
+      end
+
+      alias_method :eql?, :==
+
+      attr_reader :products
+
+      private
+
+      def assemble_products
+        if config[:products]
+          config[:products].map do |product|
+            Config::ProductConfig.new(product)
+          end
+        end
+      end
+
+      attr_reader :config
+    end
+  end
+end

data/lib/bookwatch/config/configuration_decorator.rb

@@ -0,0 +1,54 @@
+require_relative 'configuration'
+
+module Bookwatch
+  module Config
+    class ConfigurationDecorator
+      def initialize(loader: nil, config_filename: nil)
+        @loader = loader
+        @config_filename = config_filename
+      end
+
+      def generate(base_config, sections)
+        base_config.merge(
+          Configuration.new(
+            repo_links: repo_link_config(base_config, sections),
+            archive_menu: root_config(base_config).merge(section_config(sections)))
+        )
+      end
+
+      private
+
+      attr_reader :loader, :config_filename
+
+      def repo_link_config(base_config, sections)
+        if base_config.repo_link_enabled
+          sections.reduce({}) {|config, section|
+            config.merge(
+              section.destination_directory.to_s => {
+                'repo' => section.repo_name,
+                'ref' => section.source_ref,
+                'at_path' => section.at_repo_path
+              }
+            )
+          }
+        end
+      end
+
+      def root_config(base_config)
+        { '.' => base_config.archive_menu }
+      end
+
+      def section_config(sections)
+        sections.reduce({}) {|config, section|
+          config_path = section.path_to_repo_dir.join(config_filename)
+          archive_config = loader.load_key(config_path, 'archive_menu')
+          if archive_config
+            config.merge(section.desired_directory_name => archive_config)
+          else
+            config
+          end
+        }
+      end
+    end
+  end
+end

data/lib/bookwatch/config/dita_config_generator.rb

@@ -0,0 +1,61 @@
+require_relative '../../../lib/bookwatch/ingest/destination_directory'
+
+module Bookwatch
+  module Config
+    class DitaConfigGenerator
+
+      def initialize(section_hash)
+        @section_hash = section_hash
+      end
+
+      def subnav_template
+        dest_dir = Ingest::DestinationDirectory.new(section_hash.fetch('repository', {})['name'], section_hash['directory'])
+
+        "dita_subnav_#{dest_dir}"
+      end
+
+      def ditamap_location
+        section_hash['ditamap_location'] if section_hash['ditamap_location'] && !section_hash['ditamap_location'].empty?
+      end
+
+      def pdf_output_filename
+        if present?(section_hash['output_filename'])
+          filename = section_hash['output_filename']
+        elsif ditamap_location
+          filename =  ditamap_location.gsub(/\.ditamap/, '')
+        else
+          return
+        end
+
+        filename + '.pdf'
+      end
+
+      def preprocessor_config
+        {
+          'preprocessor_config' => {
+            'ditamap_location' => ditamap_location,
+            'ditaval_location' => section_hash['ditaval_location']
+          }
+        }
+      end
+
+      def to_hash
+        section_hash.tap do |hash|
+          hash.merge!(preprocessor_config)
+              .merge!('subnav_template' => subnav_template, 'output_filename' => pdf_output_filename)
+
+          hash.delete('ditaval_location')
+          hash.delete('ditamap_location')
+        end
+      end
+
+      private
+
+      attr_reader :section_hash
+      
+      def present?(value)
+        value && !value.empty?
+      end
+    end
+  end
+end

data/lib/bookwatch/config/fetcher.rb

@@ -0,0 +1,64 @@
+require_relative 'configuration'
+require_relative 'yaml_loader'
+
+module Bookwatch
+  module Config
+    class Fetcher
+      def initialize(configuration_validator, loader, config_class)
+        @loader = loader
+        @configuration_validator = configuration_validator
+        @config_class = config_class
+      end
+
+      def fetch_config
+        @base_config ||= read_config_file
+        @optional_configs ||= read_optional_configs
+
+        @config ||= validate(@base_config, @optional_configs)
+      end
+
+      def set_config_dir_path(config_dir_path)
+        @config_dir_path = File.expand_path(config_dir_path)
+      end
+
+      def set_config_file_path(config_file_path)
+        @config_file_path = File.expand_path(config_file_path)
+      end
+
+      private
+
+      attr_reader(:loader, :configuration_validator, :config, :config_file_path, :config_dir_path,
+                  :config_class)
+
+      def read_config_file
+        loader.load(config_file_path)
+
+      rescue FileNotFoundError => e
+        raise "The configuration file specified does not exist. Please create a config #{e} file at #{config_file_path} and try again."
+      rescue InvalidSyntaxError => e
+        raise syntax_error(e)
+      end
+
+      def read_optional_configs
+        Dir["#{config_dir_path}/*.yml"].map do |config_file|
+          loader.load(File.expand_path(config_file)) || {}
+        end.reduce({}, :merge)
+      rescue InvalidSyntaxError => e
+        raise syntax_error(e)
+      end
+
+      def validate(base_hash, optional_hash)
+        raise 'Your config.yml appears to be empty. Please check and try again.' unless base_hash
+
+        config_class.parse(base_hash.merge(optional_hash)).tap do |config|
+          errors = configuration_validator.exceptions(config)
+          raise errors.first if errors.any?
+        end
+      end
+
+      def syntax_error(e)
+        "There is a syntax error in your config file: \n #{e}"
+      end
+    end
+  end
+end