bookbindery 2.1.5 → 3.0.1

data/lib/bookbinder/configuration_fetcher.rb

@@ -1,28 +1,45 @@
+require_relative 'config/aws_credentials'
+require_relative 'config/cf_credentials'
 require_relative 'configuration'
 require_relative 'yaml_loader'
 
 module Bookbinder
   class ConfigurationFetcher
-    def initialize(logger, configuration_validator, loader)
+    def initialize(logger, configuration_validator, loader, credentials_provider)
       @loader = loader
       @logger = logger
       @configuration_validator = configuration_validator
+      @credentials_provider = credentials_provider
     end
 
     def fetch_config
       @config ||= validate(read_config_file)
     end
 
+    def fetch_credentials(environment = 'null-environment')
+      @credentials ||= credentials_provider.credentials("git@github.com:#{fetch_config.cred_repo}")
+      {
+        aws: Config::AwsCredentials.new(
+          @credentials.fetch('aws', {})
+        ),
+        cloud_foundry: Config::CfCredentials.new(
+          @credentials.fetch('cloud_foundry', {}),
+          environment
+        )
+      }
+    end
+
     def set_config_file_path config_file_path
       @config_file_path = File.expand_path config_file_path
     end
 
     private
 
-    attr_reader(:loader, :logger, :configuration_validator, :config, :config_file_path)
+    attr_reader(:loader, :logger, :configuration_validator, :config, :config_file_path,
+                :credentials_provider)
 
     def read_config_file
-      loader.load(config_file_path).merge('pdf_index' => nil)
+      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."
@@ -31,7 +48,14 @@ module Bookbinder
     end
 
     def validate(config_hash)
-      Configuration.new(logger, config_hash) if configuration_validator.valid?(config_hash, Configuration::CURRENT_SCHEMA_VERSION, Configuration::STARTING_SCHEMA_VERSION)
+      raise 'Your config.yml appears to be empty. Please check and try again.' unless config_hash
+
+      errors = configuration_validator.exceptions(config_hash,
+                                                  Configuration::CURRENT_SCHEMA_VERSION,
+                                                  Configuration::STARTING_SCHEMA_VERSION)
+      raise errors.first if errors.any?
+
+      Configuration.new(logger, config_hash)
     end
   end
 end

data/lib/bookbinder/configuration_validator.rb

@@ -1,188 +1,35 @@
-require 'active_support/core_ext/object/blank'
+require_relative 'validation_checkers/duplicate_section_name_checker'
+require_relative 'validation_checkers/archive_menu_checker'
+require_relative 'validation_checkers/config_version_checker'
+require_relative 'validation_checkers/required_keys_checker'
+require_relative 'validation_checkers/repository_name_presence_checker'
+require_relative 'validation_checkers/dita_section_checker'
 
 module Bookbinder
   class ConfigurationValidator
-    DuplicateSectionNameError = Class.new(RuntimeError)
-    MissingArchiveMenuPartialError = Class.new(RuntimeError)
-    EmptyArchiveItemsError = Class.new(RuntimeError)
-    ArchiveMenuNotDefinedError = Class.new(RuntimeError)
-    MissingRequiredKeyError = Class.new(RuntimeError)
-
     def initialize(logger, file_system_accessor)
       @logger = logger
       @file_system_accessor = file_system_accessor
     end
 
-    def valid?(config_hash, bookbinder_schema_version, starting_schema_version)
-      raise 'Your config.yml appears to be empty. Please check and try again.' unless config_hash
-
+    def exceptions(config_hash, bookbinder_schema_version, starting_schema_version)
       user_config_schema_version = config_hash['schema_version']
       exceptions = [
-        RequiredKeysChecker.new,
         ConfigVersionChecker.new(Version.parse(bookbinder_schema_version),
                                  Version.parse(starting_schema_version),
                                  VersionCheckerMessages.new(Version.parse(user_config_schema_version),
                                                          bookbinder_schema_version),
                                  @logger),
+        RequiredKeysChecker.new,
         DuplicateSectionNameChecker.new,
+        RepositoryNamePresenceChecker.new,
+        DitaSectionChecker.new,
         ArchiveMenuChecker.new(@file_system_accessor)
       ].map do |checker|
         checker.check(config_hash)
       end
-      exception = exceptions.compact.first
-      raise exception if exception
-
-      true
-    end
-  end
-
-  class DuplicateSectionNameChecker
-    def check(config)
-      if duplicate_section_names?(config)
-        ConfigurationValidator::DuplicateSectionNameError
-      end
-    end
-
-    private
-
-    def duplicate_section_names?(config)
-      if config['sections']
-        directory_names = config['sections'].map {|section| section['directory']}
-        directory_names.length != directory_names.uniq.length
-      else
-        false
-      end
-    end
-
-  end
 
-  class ArchiveMenuChecker
-    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.has_key?("archive_menu") && config["archive_menu"].nil?
-        ConfigurationValidator::ArchiveMenuNotDefinedError.new 'Did you mean to provide an archive menu value to display? If you use the archive_menu key, you must provide at least one value.'
-      elsif archive_items(config).include?(nil)
-        ConfigurationValidator::EmptyArchiveItemsError.new 'Did you forget to add a value to the archive_menu?'
-      elsif config.has_key?("archive_menu") && !@file_system_accessor.file_exist?(partial_location)
-        ConfigurationValidator::MissingArchiveMenuPartialError.new "You must provide a template partial named at #{partial_location}"
-      end
-    end
-
-    private
-
-    def archive_items(config)
-      config.fetch('archive_menu', [])
-    end
-
-  end
-
-  Version = Struct.new(:major, :minor, :patch) do
-    class << self
-      def parse(raw_version)
-        if raw_version
-          new(*raw_version.split('.'))
-        else
-          new(nil, nil, nil)
-        end
-      end
-    end
-
-    def valid?
-      [major, minor, patch].all?(&:present?)
-    end
-
-    def to_s
-      [major, minor, patch].compact.join('.')
-    end
-  end
-
-  class VersionCheckerMessages
-    def initialize(user_schema_version, bookbinder_schema_version)
-      @user_schema_version = user_schema_version
-      @bookbinder_schema_version = bookbinder_schema_version
-    end
-
-    def schema_now_required_message
-      "[ERROR] Bookbinder now requires a certain schema. Please see README " +
-        "and provide a schema version."
-    end
-
-    def incompatible_schema_message
-      "[ERROR] Your config.yml format, schema version #{user_schema_version}, " +
-        "is older than this version of Bookbinder can support. Please update " +
-        "your config.yml keys and format to version #{bookbinder_schema_version} " +
-        "and try again."
-    end
-
-    def unrecognized_schema_version_message
-      "[ERROR] The config schema version #{user_schema_version} is " +
-        "unrecognized by this version of Bookbinder. The latest schema version " +
-        "is #{bookbinder_schema_version}."
-    end
-
-    private
-
-    attr_reader :user_schema_version, :bookbinder_schema_version
-  end
-
-  class ConfigVersionChecker
-    def initialize(bookbinder_schema_version, starting_schema_version, messages, logger)
-      @bookbinder_schema_version = bookbinder_schema_version
-      @starting_schema_version = starting_schema_version
-      @messages = messages
-      @logger = logger
-    end
-
-    def check(config)
-      user_schema_version = Version.parse(config['schema_version'])
-      if user_schema_version.valid?
-        if user_schema_version.major > bookbinder_schema_version.major
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.minor > bookbinder_schema_version.minor
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.patch > bookbinder_schema_version.patch
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.major < bookbinder_schema_version.major
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.incompatible_schema_message
-        elsif user_schema_version.minor < bookbinder_schema_version.minor
-          @logger.warn nonbreaking_schema_message_for("minor")
-        elsif user_schema_version.patch < bookbinder_schema_version.patch
-          @logger.warn nonbreaking_schema_message_for("patch")
-        end
-      elsif bookbinder_schema_version != starting_schema_version
-        raise Configuration::ConfigSchemaUnsupportedError.new messages.schema_now_required_message
-      end
-    end
-
-    private
-
-    attr_reader :bookbinder_schema_version, :starting_schema_version, :messages
-
-    def nonbreaking_schema_message_for(version_level)
-      "[WARNING] Your schema is valid, but there exists a new #{version_level} version. Consider updating your config.yml."
-    end
-  end
-
-  class RequiredKeysChecker
-    def check(config)
-      missing_keys = []
-
-      Configuration::CONFIG_REQUIRED_KEYS.map do |required_key|
-        config_keys = config.keys
-        unless config_keys.include?(required_key)
-          missing_keys.push(required_key)
-        end
-      end
-
-      if missing_keys.length > 0
-        raise ConfigurationValidator::MissingRequiredKeyError.new(
-          "Your config.yml is missing required key(s). Required keys are #{missing_keys.join(", ")}."
-        )
-      end
+      exceptions.compact
     end
   end
 end

data/lib/bookbinder/distributor.rb

@@ -1,16 +1,21 @@
 require_relative 'app_fetcher'
+require_relative 'archive'
 require_relative 'artifact_namer'
+require_relative 'cf_command_runner'
+require_relative 'ingest/destination_directory'
+require_relative 'pusher'
+require_relative 'sheller'
 
 module Bookbinder
   class Distributor
     EXPIRATION_HOURS = 2
 
     def self.build(logger, options)
-      namespace = GitHubRepository.new(logger: logger, full_name: options[:book_repo], git_accessor: Git).short_name
+      namespace = Ingest::DestinationDirectory.new(options[:book_repo], nil)
       namer = ArtifactNamer.new(namespace, options[:build_number], 'log', '/tmp')
 
       archive = Archive.new(logger: logger, key: options[:aws_credentials].access_key, secret: options[:aws_credentials].secret_key)
-      cf_command_runner = CfCommandRunner.new(logger, options[:cf_credentials], namer.full_path)
+      cf_command_runner = CfCommandRunner.new(logger, Sheller.new, options[:cf_credentials], namer.full_path)
       cf_app_fetcher = AppFetcher.new(options[:cf_credentials].flat_routes, cf_command_runner)
 
       pusher = Pusher.new(cf_command_runner, cf_app_fetcher)
@@ -27,22 +32,21 @@ module Bookbinder
     end
 
     def distribute
-      begin
-        download if cf_credentials.download_archive_before_push?
-        push_app
-        nil
-      rescue => e
-        @logger.error(<<-ERROR.chomp)
+      download if cf_credentials.download_archive_before_push?
+      push_app
+      nil
+    rescue => e
+      @logger.error(<<-ERROR.chomp)
 [ERROR] #{e.message}
 [DEBUG INFO]
 CF organization: #{cf_credentials.organization}
 CF space: #{cf_credentials.space}
 CF account: #{cf_credentials.username}
 routes: #{cf_credentials.routes}
-        ERROR
-      ensure
-        upload_trace
-      end
+      ERROR
+      raise
+    ensure
+      upload_trace
     end
 
     private

data/lib/bookbinder/{dita_to_html_converter.rb → dita_command_creator.rb}

@@ -1,15 +1,12 @@
 require_relative '../bookbinder/values/dita_section'
 
 module Bookbinder
-  class DitaToHtmlConverter
-    DitaToHtmlLibraryFailure = Class.new(RuntimeError)
-
-    def initialize(sheller, path_to_dita_ot_library)
-      @sheller = sheller
+  class DitaCommandCreator
+    def initialize(path_to_dita_ot_library)
       @path_to_dita_ot_library = path_to_dita_ot_library
     end
 
-    def convert_to_html(dita_section, write_to: nil)
+    def convert_to_html_command(dita_section, write_to: nil)
       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:" +
@@ -32,20 +29,11 @@ module Bookbinder
       if dita_section.absolute_path_to_ditaval
         command += "-Dargs.filter=#{dita_section.absolute_path_to_ditaval} "
       end
-
-      begin
-        sheller.run_command(command)
-      rescue Sheller::ShelloutFailure
-        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
+      command
     end
 
     private
 
-    attr_reader :sheller, :path_to_dita_ot_library
+    attr_reader :path_to_dita_ot_library
   end
 end

data/lib/bookbinder/dita_preprocessor.rb

@@ -5,32 +5,34 @@ module Bookbinder
 
     ACCEPTED_IMAGE_FORMATS = %w(png jpeg jpg svg gif bmp tif tiff eps)
 
-    def initialize(dita_converter, dita_formatter, local_fs_accessor)
-      @dita_converter = dita_converter
+    def initialize(dita_formatter, local_fs_accessor)
       @dita_formatter = dita_formatter
       @local_fs_accessor = local_fs_accessor
     end
 
-    def preprocess(dita_section,
+    def preprocess(dita_sections,
                    subnavs_dir,
-                   dita_subnav_template_path)
-      if dita_section.ditamap_location
-        dita_converter.convert_to_html dita_section, write_to: dita_section.html_from_dita_section_dir
-
+                   dita_subnav_template_path,
+                   &block)
+      ditamap_location_sections = dita_sections.select { |dita_section| dita_section.ditamap_location }
+      ditamap_location_sections.each do |dita_section|
+        block.call(dita_section)
         generate_subnav(dita_section, dita_subnav_template_path, subnavs_dir)
       end
 
-      dita_formatter.format_html dita_section.html_from_dita_section_dir, dita_section.formatted_section_dir
+      dita_sections.each do |dita_section|
+        dita_formatter.format_html dita_section.html_from_dita_section_dir, dita_section.formatted_section_dir
 
-      copy_images(dita_section.path_to_local_repo, dita_section.formatted_section_dir)
+        copy_images(dita_section.path_to_local_repo, dita_section.formatted_section_dir)
 
-      local_fs_accessor.copy_contents(dita_section.formatted_section_dir,
-                                      dita_section.section_source_for_site_generator)
+        local_fs_accessor.copy_contents(dita_section.formatted_section_dir,
+                                        dita_section.section_source_for_site_generator)
+      end
     end
 
     private
 
-    attr_reader :dita_converter, :dita_formatter, :local_fs_accessor
+    attr_reader :dita_formatter, :local_fs_accessor
 
     def generate_subnav(dita_section, dita_subnav_template_path, subnavs_dir)
       dita_subnav_template_text = local_fs_accessor.read(dita_subnav_template_path)

data/lib/bookbinder/git_accessor.rb

@@ -6,12 +6,31 @@ module Bookbinder
       @cache = {}
     end
 
-    def clone(url, name, path: nil)
-      cache[[url, name, path]] ||= Git.clone(url, name, path: path)
+    def clone(url, name, path: nil, checkout: 'master')
+      cached_clone(url, name, path).tap do |git|
+        git.checkout(checkout)
+      end
+    end
+
+    def read_file(filename, from_repo: nil, checkout: 'master')
+      Dir.mktmpdir do |dir|
+        path = Pathname(dir)
+        git = _clone(from_repo, "read-file", path)
+        git.checkout(checkout)
+        path.join("read-file", filename).read
+      end
     end
 
     private
 
     attr_reader :cache
+
+    def cached_clone(url, name, path)
+      cache[[url, name, path]] ||= _clone(url, name, path)
+    end
+
+    def _clone(url, name, path)
+      Git.clone(url, name, path: path)
+    end
   end
 end

data/lib/bookbinder/git_hub_repository.rb

@@ -11,32 +11,6 @@ module Bookbinder
 
     attr_reader :full_name, :copied_to
 
-    def self.build_from_remote(logger,
-                               section_hash,
-                               git_accessor)
-      full_name = section_hash.fetch('repository', {}).fetch('name')
-      directory = section_hash['directory']
-      new(logger: logger,
-          full_name: full_name,
-          github_token: ENV['GITHUB_API_TOKEN'],
-          directory: directory,
-          git_accessor: git_accessor)
-    end
-
-    def self.build_from_local(logger,
-                              section_hash,
-                              local_repo_dir,
-                              git_accessor)
-      full_name = section_hash.fetch('repository').fetch('name')
-      directory = section_hash['directory']
-
-      new(logger: logger,
-          full_name: full_name,
-          directory: directory,
-          local_repo_dir: local_repo_dir,
-          git_accessor: git_accessor)
-    end
-
     def initialize(logger: nil,
                    full_name: nil,
                    github_token: nil,
@@ -89,23 +63,6 @@ module Bookbinder
       @copied_to = File.join(destination_dir, directory)
     end
 
-    def copy_from_local(destination_dir)
-      if File.exist?(path_to_local_repo)
-        @logger.log '  copying '.yellow + path_to_local_repo
-        destination = File.join(destination_dir, directory)
-
-        if !destination.include?(path_to_local_repo) && !File.exists?(destination)
-          FileUtils.mkdir_p(destination)
-
-          FileUtils.cp_r(File.join(path_to_local_repo, '.'), destination)
-        end
-
-        @copied_to = File.join(destination_dir, directory)
-      else
-        announce_skip
-      end
-    end
-
     def copied?
       !@copied_to.nil?
     end