bookbindery 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07f71ad52807a1f8b6a85bd211883dd095c8262f
-  data.tar.gz: 7a6157d356da84da49236483507377e2c393c671
+  metadata.gz: 56679c8bf251f348c3dd66d86317c0c848b35706
+  data.tar.gz: e6a280ed228236c2fa381393d5bdeb5f3710f8e1
 SHA512:
-  metadata.gz: 8eef0dce3fe1834608202017de1eb0ef06caf7638a70d329a97f19f08d3420399e2eac074cdf3b9f51ae71d7070ef54e85c53bbb00dbd35fd708cc61d4314592
-  data.tar.gz: f0dff29b6cb65e19bf479f636fa22108a9e06e8ecd113ae5baf7316e036703332a0d1304064064efe6db352ede94cb49a1ca9e44dfdf9b2fc940d02b4b1499d3
+  metadata.gz: b28159d61a3847f29100709af210253bc25e90ed5770273d4891ea928a24f643f7537832c36e8e3efe2780b5dfdab773b4dd3c41ab994a3ce4c8cddfcedc9cb9
+  data.tar.gz: 3463e88ed1b0044e735c0e0ffd25c572b4258cc0906985f0b74c6bfca47d1e2269895700f4ca07c694c83c2a4ee25268be1c9dd9be2e5c8284cb286564510097

data/lib/bookbinder.rb

@@ -1,10 +1,7 @@
-require 'fog'
+require 'fog/aws'
 require 'tmpdir'
 require 'ansi'
-require 'faraday'
-require 'faraday_middleware'
 require 'octokit'
-require 'padrino-contrib'
 require 'middleman-syntax'
 require 'middleman-core/cli'
 require 'middleman-core/profiling'
@@ -14,10 +11,8 @@ require 'vienna'
 require 'popen4'
 require 'puma'
 
-#require_relative 'bookbinder/shell_out'
 require_relative 'bookbinder/bookbinder_logger'
 require_relative 'bookbinder/git_client'
-#require_relative 'bookbinder/repository'
 require_relative 'bookbinder/section'
 require_relative 'bookbinder/book'
 require_relative 'bookbinder/code_example'
@@ -43,7 +38,7 @@ require_relative 'bookbinder/distributor'
 
 require_relative 'bookbinder/commands/bookbinder_command'
 require_relative 'bookbinder/commands/build_and_push_tarball'
-require_relative 'bookbinder/commands/publish'
+require_relative 'bookbinder/commands/bind'
 require_relative 'bookbinder/commands/push_local_to_staging'
 require_relative 'bookbinder/commands/push_to_prod'
 require_relative 'bookbinder/commands/run_publish_ci'
@@ -51,8 +46,6 @@ require_relative 'bookbinder/commands/update_local_doc_repos'
 require_relative 'bookbinder/commands/tag'
 require_relative 'bookbinder/commands/generate_pdf'
 
-require_relative 'bookbinder/usage_messenger'
-
 require_relative 'bookbinder/cli'
 
 # Finds the project root for both spec & production

data/lib/bookbinder/archive.rb

@@ -1,4 +1,4 @@
-require 'fog'
+require 'fog/aws'
 require 'tmpdir'
 require_relative 'bookbinder_logger'
 require_relative 'artifact_namer'

data/lib/bookbinder/archive_menu_configuration.rb

@@ -0,0 +1,34 @@
+module Bookbinder
+  class ArchiveMenuConfiguration
+    def initialize(loader: nil, config_filename: nil)
+      @loader = loader
+      @config_filename = config_filename
+    end
+
+    def generate(base_config, sections)
+      base_config.merge(
+        archive_menu: root_config(base_config).merge(section_config(sections))
+      )
+    end
+
+    private
+
+    attr_reader :loader, :config_filename
+
+    def root_config(base_config)
+      { '.' => base_config[:archive_menu] }
+    end
+
+    def section_config(sections)
+      sections.reduce({}) {|config, section|
+        config_path = section.path_to_repository.join(config_filename)
+        archive_config = loader.load_key(config_path, 'archive_menu')
+        if archive_config
+          config.merge(section.directory_name => archive_config)
+        else
+          config
+        end
+      }
+    end
+  end
+end

data/lib/bookbinder/book.rb

@@ -4,7 +4,6 @@ require_relative 'directory_helpers'
 module Bookbinder
   class Book
     include DirectoryHelperMethods
-    attr_reader :sections
 
     def self.from_remote(logger: nil, full_name: nil, destination_dir: nil, ref: nil, git_accessor: Git)
       book = new(logger: logger, full_name: full_name, target_ref: ref, git_accessor: git_accessor)
@@ -12,12 +11,23 @@ module Bookbinder
       book
     end
 
-    def initialize(logger: nil, full_name: nil, target_ref: nil, github_token: nil, sections: [], git_accessor: Git)
-      @sections = sections.map do |section|
-        GitHubRepository.new logger: logger, full_name: section['repository']['name']
+    def initialize(logger: nil,
+                   full_name: nil,
+                   target_ref: nil,
+                   github_token: nil,
+                   sections: [],
+                   git_accessor: Git)
+      @section_vcs_repos = sections.map do |section|
+        GitHubRepository.new(logger: logger,
+                             full_name: section['repository']['name'],
+                             git_accessor: git_accessor)
       end
 
-      @repository = GitHubRepository.new(logger: logger, full_name: full_name, target_ref: target_ref, github_token: github_token)
+      @repository = GitHubRepository.new(logger: logger,
+                                         full_name: full_name,
+                                         target_ref: target_ref,
+                                         github_token: github_token,
+                                         git_accessor: git_accessor)
       @git_accessor = git_accessor
     end
 
@@ -33,22 +43,12 @@ module Bookbinder
       @repository.directory
     end
 
-    def get_modification_date_for(file: nil, full_path: nil)
-      git_directory, file_relative_path = full_path.split(output_dir_name+'/')
-      begin
-        git_base_object = Git.open(git_directory)
-      rescue => e
-        raise "Invalid git repository! #{git_directory} is not a .git directory"
-      end
-      @repository.get_modification_date_for(file: file_relative_path, git: git_base_object)
-    end
-
     def copy_from_remote(destination_dir)
-      @repository.copy_from_remote(destination_dir, @git_accessor)
+      @repository.copy_from_remote(destination_dir)
     end
 
     def tag_self_and_sections_with(tag)
-      (@sections + [@repository]).each { |repo| repo.tag_with tag }
+      (@section_vcs_repos + [@repository]).each { |repo| repo.tag_with tag }
     end
   end
 end

data/lib/bookbinder/cli.rb

@@ -1,53 +1,42 @@
+require_relative 'colorizer'
 require_relative 'command_runner'
-require_relative 'local_file_system_accessor'
 require_relative 'command_validator'
-
-require_relative 'commands/build_and_push_tarball'
-require_relative 'commands/generate_pdf'
-require_relative 'commands/publish'
-require_relative 'commands/version'
-require_relative 'commands/help'
+require_relative 'configuration'
+require_relative 'repositories/command_repository'
+require_relative 'terminal'
+require_relative 'user_message_presenter'
 
 module Bookbinder
   class Cli
-    FLAGS = [
-      Commands::Version,
-      Commands::Help
-    ]
-
-    COMMANDS = [
-      Commands::BuildAndPushTarball,
-      Commands::GeneratePDF,
-      Commands::Publish,
-      Commands::PushLocalToStaging,
-      Commands::PushToProd,
-      Commands::RunPublishCI,
-      Commands::Tag,
-      Commands::UpdateLocalDocRepos,
-    ].freeze
-
     def run(args)
       command_name = args[0]
       command_arguments = args[1..-1]
 
       logger = BookbinderLogger.new
-      yaml_loader = YAMLLoader.new
-      local_file_system_accessor = LocalFileSystemAccessor.new
-      configuration_validator = ConfigurationValidator.new(logger, local_file_system_accessor)
-      configuration_fetcher = ConfigurationFetcher.new(logger, configuration_validator, yaml_loader)
-      configuration_fetcher.set_config_file_path './config.yml'
-      usage_messenger = UsageMessenger.new
-      usage_message = usage_messenger.construct_for(COMMANDS, FLAGS)
-      command_validator = CommandValidator.new usage_messenger, COMMANDS + FLAGS, usage_message
-
-      command_runner = CommandRunner.new(configuration_fetcher, usage_message, logger, COMMANDS + FLAGS)
+      commands = Repositories::CommandRepository.new(logger)
+
+      command_validator = CommandValidator.new(commands, commands.help.usage_message)
+      command_runner = CommandRunner.new(logger, commands)
+      command_name = command_name ? command_name : '--help'
+
+      colorizer = Colorizer.new
+      user_message_presenter = UserMessagePresenter.new(colorizer)
+      terminal = Terminal.new
+
+      user_message = command_validator.validate(command_name)
+      if user_message.escalation_type == EscalationType.error
+        error_message = user_message_presenter.get_error(user_message)
+        terminal.update(error_message)
+        return 1
+      elsif user_message.escalation_type == EscalationType.warn
+        warning_message = user_message_presenter.get_warning(user_message)
+        terminal.update(warning_message)
+      end
 
       begin
-        command_name ? command_validator.validate!(command_name) : command_name = '--help'
-
         command_runner.run command_name, command_arguments
 
-      rescue Commands::Publish::VersionUnsupportedError => e
+      rescue Commands::Bind::VersionUnsupportedError => e
         logger.error "config.yml at version '#{e.message}' has an unsupported API."
         1
       rescue Configuration::CredentialKeyError => e

data/lib/bookbinder/code_example.rb

@@ -1,40 +1,7 @@
-require_relative 'section'
-
 module Bookbinder
-  class CodeExample < Section
-    class InvalidSnippet < StandardError
-      def initialize(repo, marker)
-        super "Error with marker #{marker.cyan} #{'in'.red} #{repo.cyan}#{'.'.red}"
-      end
-    end
-
-    def get_snippet_and_language_at(marker)
-      unless @repository.copied?
-        @repository.announce_skip
-        return ''
-      end
-
-      prepared_snippet_at(marker)
-    end
-
-    private
-
-    def prepared_snippet_at(marker)
-      snippet = ''
-      FileUtils.cd(@repository.copied_to) { snippet = scrape_for(marker) }
-
-      raise InvalidSnippet.new(full_name, marker) if snippet.empty?
-      lines = snippet.split("\n")
-      language_match = lines[0].match(/code_snippet #{Regexp.escape(marker)} start (\w+)/)
-      language = language_match[1] if language_match
-      [lines[1..-2].join("\n"), language]
-    end
-
-    def scrape_for(marker)
-      locale = 'LC_CTYPE=C LANG=C' # Quiets 'sed: RE error: illegal byte sequence'
-      result = `#{locale} find . -exec sed -ne '/code_snippet #{marker} start/,/code_snippet #{marker} end/ p' {} \\; 2> /dev/null`
-      result = "" unless result.lines.last && result.lines.last.match(/code_snippet #{marker} end/)
-      result
-    end
-  end
+  CodeExample = Struct.new(:path_to_repository,
+                           :full_name,
+                           :copied,
+                           :destination_dir,
+                           :directory_name)
 end

data/lib/bookbinder/code_example_reader.rb

@@ -0,0 +1,40 @@
+require_relative '../../lib/bookbinder/bookbinder_logger'
+
+module Bookbinder
+  class CodeExampleReader
+    class InvalidSnippet < StandardError
+      def initialize(repo, marker)
+        super "Error with marker #{marker.cyan} #{'in'.red} #{repo.cyan}#{'.'.red}"
+      end
+    end
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def get_snippet_and_language_at(marker, path_to_repository, copied, repo_name)
+      unless copied
+        logger.log '  skipping (not found) '.magenta + repo_name
+        return ''
+      end
+
+      snippet = ''
+      FileUtils.cd(path_to_repository) { locale = 'LC_CTYPE=C LANG=C' # Quiets 'sed: RE error: illegal byte sequence'
+      result = `#{locale} find . -exec sed -ne '/code_snippet #{marker} start/,/code_snippet #{marker} end/ p' {} \\; 2> /dev/null`
+      result = "" unless result.lines.last && result.lines.last.match(/code_snippet #{marker} end/)
+      scrape_for_value = result
+      snippet = scrape_for_value }
+
+      raise InvalidSnippet.new(repo_name, marker) if snippet.empty?
+      lines = snippet.split("\n")
+      language_match = lines[0].match(/code_snippet #{Regexp.escape(marker)} start (\w+)/)
+      language = language_match[1] if language_match
+      [lines[1..-2].join("\n"), language]
+    end
+
+    private
+
+    attr_reader :logger
+
+  end
+end

data/lib/bookbinder/colorizer.rb

@@ -0,0 +1,14 @@
+require 'ansi/code'
+require 'ostruct'
+
+module Bookbinder
+
+  class Colorizer
+    Colors = OpenStruct.new(red: Proc.new { |msg| ANSI.red {msg} },
+                            yellow: Proc.new { |msg| ANSI.yellow {msg} })
+
+    def colorize(string, color)
+      color.call string.to_s
+    end
+  end
+end

data/lib/bookbinder/command_runner.rb

@@ -1,32 +1,25 @@
 require_relative 'cli_error'
+require_relative 'local_dita_to_html_converter'
+require_relative 'sheller'
 
 module Bookbinder
   class CommandRunner
-    def initialize(configuration_fetcher, usage_message, logger, commands)
-      @configuration_fetcher = configuration_fetcher
-      @usage_message = usage_message
+    def initialize(logger, commands)
       @logger = logger
       @commands = commands
     end
 
     def run(command_name, command_arguments)
-      command = commands.detect { |known_command| known_command.command_name == command_name }
-      begin
-        if command_name == '--help'
-          command.new(logger, usage_message).run command_arguments
-        else
-          command.new(logger, @configuration_fetcher).run command_arguments
-        end
-      rescue CliError::InvalidArguments
-        logger.log command.usage
-        1
-      end
+      command = commands.detect { |known_command| known_command.command_for?(command_name) }
+      command.run(command_arguments)
+    rescue CliError::InvalidArguments
+      logger.log command.usage
+      1
     end
 
     private
 
-    attr_reader :logger, :usage_message, :commands
-
+    attr_reader :logger, :commands
   end
 end
 

data/lib/bookbinder/command_validator.rb

@@ -1,24 +1,31 @@
 require_relative 'cli_error'
+require 'ostruct'
+require_relative 'user_message'
 
 module Bookbinder
   class CommandValidator
-    def initialize(usage_messenger, commands, usage_text)
-      @usage_messenger = usage_messenger
+    def initialize(commands, usage_text)
       @commands = commands
       @usage_text = usage_text
     end
 
-    def validate! command_name
-      known_command_names = commands.map(&:command_name)
+    def validate command_name
       command_type = "#{command_name}".match(/^--/) ? 'flag' : 'command'
-      if !known_command_names.include?(command_name)
-        raise CliError::UnknownCommand.new "Unrecognized #{command_type} '#{command_name}'\n" + usage_text
+      if commands.none? { |command| command.command_for?(command_name) }
+        UserMessage.new "Unrecognized #{command_type} '#{command_name}'\n" + usage_text, EscalationType.error
+      elsif command = commands.find { |command| (command.respond_to? :deprecated_command_for?) &&
+                                                                        (command.deprecated_command_for? command_name) }
+        UserMessage.new "Use of #{command_name} is deprecated. " +
+                            "The preferred usage is below: \n#{command.usage}",
+                        EscalationType.warn
+      else
+        UserMessage.new "Success", EscalationType.success
       end
     end
 
     private
 
-    attr_reader :usage_messenger, :commands, :usage_text
+    attr_reader :commands, :usage_text
   end
 end
 

data/lib/bookbinder/commands/bind.rb

@@ -0,0 +1,321 @@
+require_relative '../archive_menu_configuration'
+require_relative '../book'
+require_relative '../cli_error'
+require_relative '../directory_helpers'
+require_relative '../publisher'
+require_relative '../section'
+require_relative '../dita_section'
+require_relative '../dita_section_gatherer'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class Bind
+      VersionUnsupportedError = Class.new(RuntimeError)
+
+      include Bookbinder::DirectoryHelperMethods
+      include Commands::Naming
+
+      def initialize(logger,
+                     config_fetcher,
+                     archive_menu_config,
+                     version_control_system,
+                     file_system_accessor,
+                     static_site_generator,
+                     sitemap_generator,
+                     final_app_directory,
+                     server_director,
+                     context_dir,
+                     dita_preprocessor)
+        @logger = logger
+        @config_fetcher = config_fetcher
+        @archive_menu_config = archive_menu_config
+        @version_control_system = version_control_system
+        @file_system_accessor = file_system_accessor
+        @static_site_generator = static_site_generator
+        @sitemap_generator = sitemap_generator
+        @final_app_directory = final_app_directory
+        @server_director = server_director
+        @context_dir = context_dir
+        @dita_preprocessor = dita_preprocessor
+      end
+
+      def usage
+        ["bind <local|github> [--verbose]",
+         "Bind the sections specified in config.yml from <local> or <github> into the final_app directory"]
+      end
+
+      def command_for?(test_command_name)
+        %w(bind publish).include?(test_command_name)
+      end
+
+      def deprecated_command_for?(command_name)
+        %w(publish).include?(command_name)
+      end
+
+      def run(cli_arguments)
+        raise CliError::InvalidArguments unless arguments_are_valid?(cli_arguments)
+        @section_repository = Repositories::SectionRepository.new(logger)
+        @gem_root = File.expand_path('../../../../', __FILE__)
+
+        @publisher = Publisher.new(logger, sitemap_generator, static_site_generator, server_director, file_system_accessor)
+
+        location = cli_arguments[0]
+
+        output_paths = output_directory_paths(location)
+        publish_config = publish_config(location)
+        @versions = publish_config.fetch(:versions, [])
+        @book_repo = publish_config[:book_repo]
+
+        master_middleman_dir = output_paths.fetch(:master_middleman_dir)
+        output_dir = output_paths.fetch(:output_dir)
+
+        dita_processing_dir = File.join output_dir, 'dita'
+        dita_section_dir = File.join dita_processing_dir, 'dita_sections'
+        dita_processed_dir = File.join dita_processing_dir, 'html_from_dita'
+        formatted_dir = File.join dita_processing_dir, 'site_generator_ready'
+
+        master_dir = File.join output_dir, 'master_middleman'
+        workspace_dir = File.join master_dir, 'source'
+        prepare_directories(final_app_directory,
+                            output_dir,
+                            workspace_dir,
+                            master_middleman_dir,
+                            master_dir,
+                            dita_processing_dir,
+                            formatted_dir)
+
+        dita_section_config_hash = config.dita_sections || {}
+        dita_sections = dita_section_config_hash.map do |dita_section_config|
+          relative_path_to_dita_map = dita_section_config['ditamap_location']
+          full_name = dita_section_config.fetch('repository', {}).fetch('name')
+          target_ref = dita_section_config.fetch('repository', {})['ref']
+          directory = dita_section_config['directory']
+
+          DitaSection.new(nil, relative_path_to_dita_map, full_name, target_ref, directory)
+        end
+
+        if location == 'github'
+          dita_section_gatherer = DitaSectionGatherer.new(version_control_system, logger)
+          final_dita_sections = dita_section_gatherer.gather(dita_sections, to: dita_section_dir)
+        else
+          final_dita_sections = dita_sections.map do |dita_section|
+            relative_path_to_dita_map = dita_section.ditamap_location
+            full_name = dita_section.full_name
+            target_ref = dita_section.target_ref
+            directory = dita_section.directory
+
+            path_to_local_copy = File.join output_paths[:local_repo_dir], directory
+
+            DitaSection.new(path_to_local_copy, relative_path_to_dita_map, full_name, target_ref, directory)
+          end
+        end
+
+        dita_preprocessor.preprocess final_dita_sections, dita_processed_dir, formatted_dir, workspace_dir
+
+        sections = gather_sections(workspace_dir, output_paths)
+
+        subnavs = subnavs_by_dir_name(sections)
+
+        success = publisher.publish(
+          subnavs,
+          {verbose: cli_arguments.include?('--verbose')},
+          output_paths,
+          archive_menu_config.generate(publish_config, sections)
+        )
+
+        success ? 0 : 1
+      end
+
+      private
+
+      attr_reader :publisher,
+                  :version_control_system,
+                  :config_fetcher,
+                  :archive_menu_config,
+                  :logger,
+                  :file_system_accessor,
+                  :static_site_generator,
+                  :final_app_directory,
+                  :sitemap_generator,
+                  :server_director,
+                  :context_dir,
+                  :dita_preprocessor
+
+      def gather_sections(workspace, output_paths)
+        config.sections.map do |attributes|
+
+          local_repo_dir = output_paths[:local_repo_dir]
+          vcs_repo =
+              if local_repo_dir
+                GitHubRepository.
+                    build_from_local(logger, attributes, local_repo_dir, version_control_system).
+                    tap { |repo| repo.copy_from_local(workspace) }
+              else
+                GitHubRepository.
+                    build_from_remote(logger, attributes, nil, version_control_system).
+                    tap { |repo| repo.copy_from_remote(workspace) }
+              end
+
+          @section_repository.get_instance(attributes,
+                                           vcs_repo: vcs_repo,
+                                           destination_dir: workspace,
+                                           build: ->(*args) { Section.new(*args) })
+        end
+      end
+
+      def prepare_directories(final_app,
+                              output_dir,
+                              middleman_source,
+                              master_middleman_dir,
+                              middleman_dir,
+                              dita_processing_dir,
+                              formatted_dir)
+        forget_sections(output_dir)
+        file_system_accessor.remove_directory File.join final_app, '.'
+        file_system_accessor.remove_directory dita_processing_dir
+        file_system_accessor.make_directory output_dir
+        file_system_accessor.make_directory formatted_dir
+        file_system_accessor.make_directory File.join dita_processing_dir, 'dita_sections'
+        file_system_accessor.make_directory File.join final_app, 'public'
+        file_system_accessor.make_directory middleman_source
+
+        copy_directory_from_gem 'template_app', final_app
+        copy_directory_from_gem 'master_middleman', middleman_dir
+        file_system_accessor.copy File.join(master_middleman_dir, '.'), middleman_dir
+
+        copy_version_master_middleman(middleman_source)
+      end
+
+      def forget_sections(middleman_scratch)
+        file_system_accessor.remove_directory File.join middleman_scratch, '.'
+      end
+
+      def copy_directory_from_gem(dir, output_dir)
+        file_system_accessor.copy File.join(@gem_root, "#{dir}/."), output_dir
+      end
+
+      # Copy the index file from each version into the version's directory. Because version
+      # subdirectories are sections, this is the only way they get content from their master
+      # middleman directory.
+      def copy_version_master_middleman(dest_dir)
+        @versions.each do |version|
+          Dir.mktmpdir(version) do |tmpdir|
+            book = Book.from_remote(logger: logger,
+                                    full_name: @book_repo,
+                                    destination_dir: tmpdir,
+                                    ref: version,
+                                    git_accessor: version_control_system)
+            index_source_dir = File.join(tmpdir, book.directory, 'master_middleman', source_dir_name)
+            index_dest_dir = File.join(dest_dir, version)
+            file_system_accessor.make_directory(index_dest_dir)
+
+            Dir.glob(File.join(index_source_dir, 'index.*')) do |f|
+              file_system_accessor.copy(File.expand_path(f), index_dest_dir)
+            end
+          end
+        end
+      end
+
+      def output_directory_paths(location)
+        local_repo_dir = (location == 'local') ? File.expand_path('..', context_dir) : nil
+
+        {
+          final_app_dir: final_app_directory,
+          local_repo_dir: local_repo_dir,
+          output_dir: File.join(context_dir, output_dir_name),
+          master_middleman_dir: layout_repo_path(local_repo_dir)
+        }
+      end
+
+      def publish_config(location)
+        arguments = {
+            sections: config.sections,
+            book_repo: config.book_repo,
+            host_for_sitemap: config.public_host,
+            archive_menu: config.archive_menu
+        }
+
+        optional_arguments = {}
+        optional_arguments.merge!(template_variables: config.template_variables) if config.respond_to?(:template_variables)
+        if publishing_to_github? location
+          config.versions.each { |version| arguments[:sections].concat sections_from version }
+          optional_arguments.merge!(versions: config.versions)
+        end
+
+        arguments.merge! optional_arguments
+      end
+
+      def config
+        config_fetcher.fetch_config
+      end
+
+      def sections_from(version)
+        Dir.mktmpdir('book_checkout') do |temp_workspace|
+          book = Book.from_remote(logger: logger,
+                                  full_name: config.book_repo,
+                                  destination_dir: temp_workspace,
+                                  ref: version,
+                                  git_accessor: version_control_system,
+          )
+
+          book_checkout_value = File.join temp_workspace, book.directory
+          config_file = File.join book_checkout_value, 'config.yml'
+          attrs = YAML.load(File.read(config_file))['sections']
+          raise VersionUnsupportedError.new(version) if attrs.nil?
+
+          attrs.map do |section_hash|
+            section_hash['repository']['ref'] = version
+            section_hash['directory'] = File.join(version, section_hash['directory'])
+            section_hash
+          end
+        end
+      end
+
+      def layout_repo_path(local_repo_dir)
+        if config.has_option?('layout_repo')
+          if local_repo_dir
+            File.join(local_repo_dir, config.layout_repo.split('/').last)
+          else
+            section = {'repository' => {'name' => config.layout_repo}}
+            destination_dir = Dir.mktmpdir
+            repository = GitHubRepository.build_from_remote(logger,
+                                                            section,
+                                                            'master',
+                                                            version_control_system)
+            repository.copy_from_remote(destination_dir)
+            if repository
+              File.join(destination_dir, repository.directory)
+            else
+              raise 'failed to fetch repository'
+            end
+          end
+        else
+          File.absolute_path('master_middleman')
+        end
+      end
+
+      def arguments_are_valid?(arguments)
+        return false unless arguments.any?
+        verbose           = arguments[1] && arguments[1..-1].include?('--verbose')
+        tag_provided      = arguments[1] && (arguments[1..-1] - ['--verbose']).any?
+        nothing_special   = arguments[1..-1].empty?
+
+        %w(local github).include?(arguments[0]) && (tag_provided || verbose || nothing_special)
+      end
+
+      def publishing_to_github?(publish_location)
+        config.has_option?('versions') && publish_location != 'local'
+      end
+
+      def subnavs_by_dir_name(sections)
+        sections.reduce({}) do |subnavs, section|
+          namespace = section.directory.gsub('/', '_')
+          template = section.subnav_template || 'default'
+
+          subnavs.merge(namespace => template)
+        end
+      end
+    end
+  end
+end