bookbindery 1.0.0 → 2.0.0

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

data/lib/bookbinder/commands/build_and_push_tarball.rb

@@ -5,7 +5,7 @@ require_relative '../archive'
 module Bookbinder
   module Commands
     class BuildAndPushTarball < BookbinderCommand
-      extend Commands::Naming
+      include Commands::Naming
 
       class MissingBuildNumber < StandardError
         def initialize
@@ -13,17 +13,18 @@ module Bookbinder
         end
       end
 
-      def self.usage
-        "build_and_push_tarball \t  \t  \t Create a tarball from the final_app directory and push to the S3 bucket specified in your credentials.yml"
+      def usage
+        [command_name,
+         "Create a tarball from the final_app directory and push to the S3 bucket specified in your credentials.yml"]
       end
 
       def run(_)
         raise MissingBuildNumber unless ENV['BUILD_NUMBER']
         config = configuration_fetcher.fetch_config
         aws_credentials = config.aws_credentials
-        repository = Archive.new(logger: @logger, key: aws_credentials.access_key, secret: aws_credentials.secret_key)
-        repository.create_and_upload_tarball(build_number: ENV['BUILD_NUMBER'], bucket: aws_credentials.green_builds_bucket,
-                                             namespace: GitHubRepository.new(logger: @logger, full_name: config.book_repo).short_name)
+        archive = Archive.new(logger: @logger, key: aws_credentials.access_key, secret: aws_credentials.secret_key)
+        archive.create_and_upload_tarball(build_number: ENV['BUILD_NUMBER'], bucket: aws_credentials.green_builds_bucket,
+                                          namespace: GitHubRepository.new(logger: @logger, full_name: config.book_repo, git_accessor: Git).short_name)
         0
       end
     end

data/lib/bookbinder/commands/chain.rb

@@ -0,0 +1,11 @@
+module Bookbinder
+  module Commands
+    module Chain
+      private
+
+      def command_chain(*commands)
+        commands.all? {|command| command[] == 0} ? 0 : 1
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/generate_pdf.rb

@@ -6,7 +6,7 @@ require_relative 'naming'
 module Bookbinder
   module Commands
     class GeneratePDF < BookbinderCommand
-      extend Commands::Naming
+      include Commands::Naming
 
       class AppNotPublished < StandardError
         def initialize(msg='You must publish locally before you generate a PDF.')
@@ -32,8 +32,9 @@ module Bookbinder
         end
       end
 
-      def self.usage
-        "generate_pdf [<file_name>.yml] \t \t Generate a PDF from the files specified in <file_name.yml>"
+      def usage
+        ["generate_pdf [<file_name>.yml]",
+         "Generate a PDF from the files specified in <file_name.yml>"]
       end
 
       def run(params)

data/lib/bookbinder/commands/help.rb

@@ -1,21 +1,21 @@
+require_relative 'naming'
+
 module Bookbinder
   module Commands
     class Help
-      def initialize(logger, usage_message)
-        @logger = logger
-        @usage_message = usage_message
-      end
+      include Commands::Naming
 
-      def self.to_s
-        'help'
+      def initialize(logger, other_commands)
+        @logger = logger
+        @other_commands = other_commands
       end
 
-      def self.command_name
+      def command_name
         '--help'
       end
 
-      def self.usage
-        "--help \t \t \t \t \t Print this message"
+      def usage
+        [command_name, "Print this message"]
       end
 
       def run(*)
@@ -23,9 +23,48 @@ module Bookbinder
         0
       end
 
+      def usage_message
+        [usage_header, command_usage_messages].join("\n")
+      end
+
       private
 
-      attr_reader :logger, :usage_message
+      def command_usage_messages
+        (flags + standard_commands).reduce('') { |message, command|
+          "#{message}#{usage_indent}#{formatted_usage(command)}\n"
+        }
+      end
+
+      def formatted_usage(command)
+        "#{command.usage[0].ljust(chars_for_usage_definition)}#{command.usage[1]}"
+      end
+
+      def usage_indent
+        " " * 4
+      end
+
+      def chars_for_usage_definition
+        33
+      end
+
+      def flags
+        other_commands.select(&:flag?) + [self]
+      end
+
+      def standard_commands
+        other_commands.reject(&:flag?)
+      end
+
+      def usage_header
+        <<TEXT
+
+  \e[1;39;49mDocumentation\e[0m: https://github.com/pivotal-cf/docs-bookbinder
+
+  \e[1;39;49mUsage\e[0m: bookbinder <command|flag> [args]
+TEXT
+      end
+
+      attr_reader :logger, :other_commands
     end
   end
 end

data/lib/bookbinder/commands/naming.rb

@@ -2,7 +2,15 @@ module Bookbinder
   module Commands
     module Naming
       def command_name
-        name.demodulize.underscore
+        self.class.name.demodulize.underscore
+      end
+
+      def command_for?(test_command_name)
+        command_name == test_command_name
+      end
+
+      def flag?
+        command_name.match(/^--/)
       end
     end
   end

data/lib/bookbinder/commands/push_local_to_staging.rb

@@ -5,10 +5,11 @@ require_relative 'naming'
 module Bookbinder
   module Commands
     class PushLocalToStaging < BookbinderCommand
-      extend Commands::Naming
+      include Commands::Naming
 
-      def self.usage
-        "push_local_to_staging \t \t  \t Push the contents of final_app to the staging host specified in credentials.yml"
+      def usage
+        [command_name,
+         "Push the contents of final_app to the staging host specified in credentials.yml"]
       end
 
       def run(_)

data/lib/bookbinder/commands/push_to_prod.rb

@@ -3,21 +3,35 @@ require_relative 'bookbinder_command'
 require_relative 'naming'
 
 module Bookbinder
+  class PushToProdValidator
+    MissingRequiredKeyError = Class.new(RuntimeError)
+  end
+
   module Commands
-    class PushToProd < BookbinderCommand
-      extend Commands::Naming
+    class PushToProd
+      include Commands::Naming
+      CONFIG_REQUIRED_KEYS = %w(cred_repo)
+
+      def initialize(logger, configuration_fetcher)
+        @logger = logger
+        @configuration_fetcher = configuration_fetcher
+      end
 
-      def self.usage
-        "push_to_prod [build_#] \t \t \t Push latest or <build_#> from your S3 bucket to the production host specified in credentials.yml"
+      def usage
+        ["push_to_prod [build_#]",
+         "Push latest or <build_#> from your S3 bucket to the production host specified in credentials.yml"]
       end
 
       def run(arguments)
+        validate
         Distributor.build(@logger, options(arguments)).distribute
         0
       end
 
       private
 
+      attr_reader :configuration_fetcher
+
       def options(arguments)
         {
           app_dir: Dir.mktmpdir,
@@ -30,6 +44,24 @@ module Bookbinder
           production: true
         }
       end
+
+      def config
+        @config ||= configuration_fetcher.fetch_config
+      end
+
+      def validate
+        missing_keys = []
+        CONFIG_REQUIRED_KEYS.map do |required_key|
+          unless config.has_option?(required_key)
+            missing_keys.push(required_key)
+          end
+        end
+
+        if missing_keys.length > 0
+          raise PushToProdValidator::MissingRequiredKeyError.new "Your config.yml is missing required key(s). The require keys for this commands are " + missing_keys.join(", ")
+        end
+      end
+
     end
   end
 end

data/lib/bookbinder/commands/run_publish_ci.rb

@@ -1,42 +1,39 @@
-require_relative 'bookbinder_command'
+require_relative 'bind'
+require_relative 'build_and_push_tarball'
+require_relative 'chain'
 require_relative 'naming'
-require_relative 'publish'
 require_relative 'push_local_to_staging'
-require_relative 'build_and_push_tarball'
 
 module Bookbinder
   module Commands
-    class RunPublishCI < BookbinderCommand
-      extend Commands::Naming
+    class RunPublishCI
+      include Commands::Naming
+      include Commands::Chain
 
-      def self.usage
-        "run_publish_ci \t \t \t \t Run publish, push_local_to_staging, and build_and_push_tarball for CI purposes"
+      def usage
+        [command_name,
+         "Run publish, push_local_to_staging, and build_and_push_tarball for CI purposes"]
       end
 
-      def run(cli_args)
-        check_params
-        all_successfully_ran = publish(cli_args) == 0 && push_to_staging == 0 && push_tarball == 0
-        all_successfully_ran ? 0 : 1
+      def initialize(publish_command, push_local_to_staging_command, build_and_push_tarball_command)
+        @publish_command = publish_command
+        @push_local_to_staging_command = push_local_to_staging_command
+        @build_and_push_tarball_command = build_and_push_tarball_command
       end
 
-      private
-
-      def check_params
+      def run(cli_args)
         raise BuildAndPushTarball::MissingBuildNumber unless ENV['BUILD_NUMBER']
-        config.book_repo
-      end
 
-      def publish(cli_args)
-        Publish.new(@logger, @configuration_fetcher).run(['github'] + cli_args)
+        command_chain(
+          ->{publish_command.run(['github'] + cli_args)},
+          ->{push_local_to_staging_command.run([])},
+          ->{build_and_push_tarball_command.run([])}
+        )
       end
 
-      def push_to_staging
-        PushLocalToStaging.new(@logger, @configuration_fetcher).run []
-      end
+      private
 
-      def push_tarball
-        BuildAndPushTarball.new(@logger, @configuration_fetcher).run []
-      end
+      attr_reader :publish_command, :push_local_to_staging_command, :build_and_push_tarball_command
     end
   end
 end

data/lib/bookbinder/commands/tag.rb

@@ -8,10 +8,10 @@ require_relative 'naming'
 module Bookbinder
   module Commands
     class Tag < BookbinderCommand
-      extend Commands::Naming
+      include Commands::Naming
 
-      def self.usage
-        "tag <git tag> \t \t \t \t Apply the specified <git tag> to your book and all sections of your book"
+      def usage
+        ["tag <git tag>", "Apply the specified <git tag> to your book and all sections of your book"]
       end
 
       def run(params)

data/lib/bookbinder/commands/update_local_doc_repos.rb

@@ -4,10 +4,11 @@ require_relative 'naming'
 module Bookbinder
   module Commands
     class UpdateLocalDocRepos < BookbinderCommand
-      extend Commands::Naming
+      include Commands::Naming
 
-      def self.usage
-        "update_local_doc_repos \t \t \t Run `git pull` on all sections that exist at the same directory level as your book directory"
+      def usage
+        [command_name,
+         "Run `git pull` on all sections that exist at the same directory level as your book directory"]
       end
 
       def run(_)
@@ -20,7 +21,7 @@ module Bookbinder
       def repo_for(section_config)
         local_repo_dir = File.absolute_path('../')
         GitHubRepository.new(logger: @logger, full_name: section_config['repository']['name'],
-                             local_repo_dir: local_repo_dir)
+                             local_repo_dir: local_repo_dir, git_accessor: Git)
       end
     end
   end