bookbindery 2.1.5 → 3.0.1

data/lib/bookbinder/ingest/cloner_factory.rb

@@ -4,22 +4,23 @@ require_relative 'local_filesystem_cloner'
 module Bookbinder
   module Ingest
     class ClonerFactory
-      def initialize(logger, version_control_system)
+      def initialize(logger, filesystem, version_control_system)
         @logger = logger
+        @filesystem = filesystem
         @version_control_system = version_control_system
       end
 
       def produce(source, user_repo_dir)
         if user_repo_dir
-          LocalFilesystemCloner.new(logger, version_control_system, user_repo_dir)
+          LocalFilesystemCloner.new(logger, filesystem, user_repo_dir)
         else
-          GitHubRepositoryCloner.new(logger, version_control_system)
+          GitHubRepositoryCloner.new(version_control_system)
         end
       end
 
       private
 
-      attr_reader :logger, :version_control_system
+      attr_reader :logger, :filesystem, :version_control_system
     end
   end
 end

data/lib/bookbinder/ingest/destination_directory.rb

@@ -0,0 +1,15 @@
+module Bookbinder
+  module Ingest
+    DestinationDirectory = Struct.new(:full_repo_name, :desired_destination_dir_name) do
+      def to_str
+        desired_destination_dir_name || full_repo_name.split('/')[1]
+      end
+
+      alias :to_s :to_str
+
+      def ==(other)
+        to_str == other
+      end
+    end
+  end
+end

data/lib/bookbinder/ingest/git_hub_repository_cloner.rb

@@ -1,26 +1,35 @@
+require_relative 'destination_directory'
+require_relative 'working_copy'
+
 module Bookbinder
   module Ingest
     class GitHubRepositoryCloner
-      def initialize(logger, version_control_system)
-        @logger = logger
+      def initialize(version_control_system)
         @version_control_system = version_control_system
       end
 
-      def call(from: nil,
-               ref: nil,
-               parent_dir: nil,
-               dir_name: nil)
-        GitHubRepository.
-          build_from_remote(logger,
-                            {'repository' => {'name' => from},
-                             'directory' => dir_name},
-                             version_control_system).
-                             tap { |repo| repo.copy_from_remote(parent_dir, ref) }
+      def call(source_repo_name: nil,
+               source_ref: "master",
+               destination_parent_dir: nil,
+               destination_dir_name: nil)
+        dest_dir = DestinationDirectory.new(source_repo_name, destination_dir_name)
+        copied_to = Pathname(destination_parent_dir).join(dest_dir)
+        version_control_system.clone(
+          "git@github.com:#{source_repo_name}",
+          dest_dir,
+          path: destination_parent_dir,
+          checkout: source_ref
+        )
+        WorkingCopy.new(
+          copied_to: copied_to,
+          directory: destination_dir_name,
+          full_name: source_repo_name,
+        )
       end
 
       private
 
-      attr_reader :logger, :version_control_system
+      attr_reader :version_control_system
     end
   end
 end

data/lib/bookbinder/ingest/local_filesystem_cloner.rb

@@ -1,28 +1,52 @@
+require_relative '../deprecated_logger'
+require_relative 'working_copy'
+
 module Bookbinder
   module Ingest
     class LocalFilesystemCloner
-      def initialize(logger, version_control_system, user_repo_dir)
+      def initialize(logger, filesystem, user_repo_dir)
         @logger = logger
-        @version_control_system = version_control_system
         @user_repo_dir = user_repo_dir
+        @filesystem = filesystem
       end
 
-      def call(from: nil,
-               ref: nil,
-               parent_dir: nil,
-               dir_name: nil)
-        GitHubRepository.
-          build_from_local(logger,
-                           {'repository' => {'name' => from},
-                            'directory' => dir_name},
-                            user_repo_dir,
-                            version_control_system).
-                            tap { |repo| repo.copy_from_local(parent_dir) }
+      def call(source_repo_name: nil,
+               source_ref: nil,
+               destination_parent_dir: nil,
+               destination_dir_name: nil)
+        copied_to = copy!(
+          WorkingCopy.new(repo_dir: user_repo_dir, full_name: source_repo_name),
+          Pathname(destination_parent_dir).join(DestinationDirectory.new(source_repo_name, destination_dir_name))
+        )
+        WorkingCopy.new(
+          copied_to: copied_to,
+          directory: destination_dir_name,
+          full_name: source_repo_name,
+        )
       end
 
       private
 
-      attr_reader :logger, :version_control_system, :user_repo_dir
+      attr_reader :logger, :filesystem, :user_repo_dir
+
+      def copy!(source_copy, dest_dir)
+        source_exists = filesystem.file_exist?(source_copy.path)
+
+        if source_exists && filesystem.file_exist?(dest_dir)
+          announce_copy(source_copy)
+          dest_dir
+        elsif source_exists
+          announce_copy(source_copy)
+          filesystem.copy_contents(source_copy.path, dest_dir)
+          dest_dir
+        else
+          logger.log '  skipping (not found) '.magenta + source_copy.path.to_s
+        end
+      end
+
+      def announce_copy(source_copy)
+        logger.log '  copying '.yellow + source_copy.path.to_s
+      end
     end
   end
 end

data/lib/bookbinder/ingest/working_copy.rb

@@ -0,0 +1,31 @@
+require_relative 'destination_directory'
+
+module Bookbinder
+  module Ingest
+    class WorkingCopy
+      def initialize(repo_dir: nil,
+                     copied_to: nil,
+                     directory: nil,
+                     full_name: nil)
+        @repo_dir = repo_dir
+        @copied_to = copied_to
+        @directory = directory
+        @full_name = full_name
+      end
+
+      attr_reader :copied_to, :full_name
+
+      def copied?
+        ! copied_to.nil?
+      end
+
+      def directory
+        DestinationDirectory.new(full_name, @directory).to_s
+      end
+
+      def path
+        Pathname(@repo_dir).join(directory)
+      end
+    end
+  end
+end

data/lib/bookbinder/local_dita_section_gatherer.rb

@@ -10,15 +10,16 @@ module Bookbinder
         relative_path_to_dita_val = dita_section_config['ditaval_location']
         full_name = dita_section_config.fetch('repository', {}).fetch('name')
         target_ref = dita_section_config.fetch('repository', {})['ref']
-        directory = dita_section_config['directory']
-        path_to_local_copy = output_locations.local_repo_dir.join(directory)
+        desired_destination_directory_name = dita_section_config['directory']
+        local_source_directory_name = full_name.split('/').last
+        path_to_local_copy = output_locations.local_repo_dir.join(local_source_directory_name)
 
         DitaSection.new(path_to_local_copy,
                         relative_path_to_dita_map,
                         relative_path_to_dita_val,
                         full_name,
                         target_ref,
-                        directory,
+                        desired_destination_directory_name,
                         output_locations)
       end
     end

data/lib/bookbinder/local_file_system_accessor.rb

@@ -44,10 +44,7 @@ module Bookbinder
         FileUtils.mkdir_p(dest)
       end
 
-      contents = Dir.glob File.join(src, '**')
-      contents.each do |dir|
-        FileUtils.cp_r dir, dest
-      end
+      FileUtils.cp_r "#{src}/.", dest
     end
 
     def copy_including_intermediate_dirs(file, root, dest)

data/lib/bookbinder/middleman_runner.rb

@@ -37,24 +37,21 @@ module Bookbinder
       @git_accessor = git_accessor
     end
 
-    def run(middleman_dir,
-            workspace_dir,
-            template_variables,
-            local_repo_dir,
+    def run(output_locations,
+            config,
+            cloner,
             verbose = false,
-            subnav_templates_by_directory = {},
-            production_host=nil,
-            archive_menu=nil)
+            subnav_templates_by_directory = {})
       @logger.log "\nRunning middleman...\n\n"
 
-      within(middleman_dir) do
-        invoke_against_current_dir(local_repo_dir,
-                                   workspace_dir,
-                                   production_host,
+      within(output_locations.master_dir) do
+        invoke_against_current_dir(output_locations.workspace_dir,
+                                   config[:host_for_sitemap],
                                    subnav_templates_by_directory,
-                                   template_variables,
-                                   archive_menu,
-                                   verbose)
+                                   config.fetch(:template_variables, {}),
+                                   config[:archive_menu],
+                                   verbose,
+                                   cloner)
       end
     end
 
@@ -65,31 +62,30 @@ module Bookbinder
     def within(temp_root, &block)
       Middleman::Cli::Build.instance_variable_set(:@_shared_instance, nil)
       original_mm_root  = ENV['MM_ROOT']
-      ENV['MM_ROOT']    = temp_root
+      ENV['MM_ROOT']    = temp_root.to_s
 
       Dir.chdir(temp_root) { block.call }
 
       ENV['MM_ROOT']    = original_mm_root
     end
 
-    def invoke_against_current_dir(local_repo_dir,
-                                   workspace_dir,
+    def invoke_against_current_dir(workspace_dir,
                                    production_host,
                                    subnav_templates,
                                    template_variables,
                                    archive_menu,
-                                   verbose)
+                                   verbose,
+                                   cloner)
       builder = Middleman::Cli::Build.shared_instance(verbose)
 
       config = {
-          local_repo_dir: local_repo_dir,
-          workspace: workspace_dir,
-          production_host: production_host,
-          git_accessor: git_accessor,
-          template_variables: template_variables,
-          relative_links: false,
-          subnav_templates: subnav_templates,
-          archive_menu: archive_menu
+        archive_menu: archive_menu,
+        cloner: cloner,
+        production_host: production_host,
+        relative_links: false,
+        subnav_templates: subnav_templates,
+        template_variables: template_variables,
+        workspace: workspace_dir,
       }
 
       config.each { |k, v| builder.config[k] = v }

data/lib/bookbinder/remote_yaml_credential_provider.rb

@@ -1,20 +1,20 @@
 require 'yaml'
-require 'tempfile'
+require 'ansi/code'
 
 module Bookbinder
   class RemoteYamlCredentialProvider
-    def initialize(logger, repository)
+    def initialize(logger, version_control_system)
       @logger = logger
-      @repository = repository
+      @version_control_system = version_control_system
     end
 
-    def credentials
-      @logger.log "Processing #{@repository.full_name.cyan}"
-      Dir.mktmpdir do |destination_dir|
-        @repository.copy_from_remote(destination_dir, 'master')
-        cred_file_yaml = File.join(destination_dir, @repository.short_name, 'credentials.yml')
-        YAML.load_file(cred_file_yaml)
-      end
+    def credentials(repo_url)
+      logger.log "Processing #{ANSI.cyan{repo_url}}"
+      YAML.load(version_control_system.read_file("credentials.yml", from_repo: repo_url))
     end
+
+    private
+
+    attr_reader :logger, :version_control_system
   end
 end

data/lib/bookbinder/repositories/command_repository.rb

@@ -1,19 +1,24 @@
 Dir.glob(File.expand_path('../../commands/*.rb', __FILE__)).each do |command_file|
   require command_file
 end
+
+require_relative '../commands/bind/directory_preparer'
+require_relative '../config/bind_config_factory'
 require_relative '../configuration_fetcher'
 require_relative '../configuration_validator'
+require_relative '../dita_command_creator'
 require_relative '../dita_html_to_middleman_formatter'
 require_relative '../dita_preprocessor'
 require_relative '../html_document_manipulator'
 require_relative '../ingest/cloner_factory'
-require_relative '../dita_to_html_converter'
 require_relative '../local_file_system_accessor'
 require_relative '../middleman_runner'
 require_relative '../post_production/sitemap_writer'
+require_relative '../remote_yaml_credential_provider'
+require_relative '../sheller'
 require_relative '../subnav_formatter'
 require_relative '../yaml_loader'
-require_relative '../config/bind_config_factory'
+require_relative 'section_repository'
 
 module Bookbinder
   module Repositories
@@ -51,7 +56,6 @@ module Bookbinder
       def standard_commands
         @standard_commands ||= [
           build_and_push_tarball,
-          Commands::GeneratePDF.new(logger, configuration_fetcher),
           bind,
           Commands::PushFromLocal.new(logger, configuration_fetcher, 'acceptance'),
           push_local_to_staging,
@@ -82,8 +86,12 @@ module Bookbinder
           final_app_directory,
           File.absolute_path('.'),
           dita_preprocessor,
-          Ingest::ClonerFactory.new(logger, version_control_system),
-          DitaSectionGathererFactory.new(version_control_system, logger)
+          Ingest::ClonerFactory.new(logger, local_file_system_accessor, version_control_system),
+          DitaSectionGathererFactory.new(version_control_system, logger),
+          Repositories::SectionRepository.new(logger),
+          dita_command_creator,
+          Sheller.new,
+          Commands::BindComponents::DirectoryPreparer.new(logger, local_file_system_accessor, version_control_system)
         )
       end
 
@@ -110,7 +118,8 @@ module Bookbinder
         @configuration_fetcher ||= ConfigurationFetcher.new(
           logger,
           ConfigurationValidator.new(logger, local_file_system_accessor),
-          config_loader
+          config_loader,
+          RemoteYamlCredentialProvider.new(logger, version_control_system)
         ).tap do |fetcher|
           fetcher.set_config_file_path './config.yml'
         end
@@ -126,15 +135,12 @@ module Bookbinder
 
       def dita_preprocessor
         @dita_preprocessor ||=
-            DitaPreprocessor.new(local_dita_processor,
-                                 dita_html_to_middleman_formatter,
+            DitaPreprocessor.new(dita_html_to_middleman_formatter,
                                  local_file_system_accessor)
       end
 
-      def local_dita_processor
-        @local_dita_processor ||=
-            DitaToHtmlConverter.new(Sheller.new(logger),
-                                         ENV['PATH_TO_DITA_OT_LIBRARY'])
+      def dita_command_creator
+        @dita_command_creator ||= DitaCommandCreator.new(ENV['PATH_TO_DITA_OT_LIBRARY'])
       end
 
       def dita_html_to_middleman_formatter

data/lib/bookbinder/repositories/section_repository.rb

@@ -7,20 +7,20 @@ module Bookbinder
         @logger = logger
       end
 
-      def get_instance(attributes,
-                       vcs_repo: nil,
+      def get_instance(section_config,
+                       working_copy: nil,
                        destination_dir: Dir.mktmpdir,
                        &build)
-        repository_config = attributes['repository']
+        repository_config = section_config['repository']
         raise "section repository '#{repository_config}' is not a hash" unless repository_config.is_a?(Hash)
         raise "section repository '#{repository_config}' missing name key" unless repository_config['name']
         logger.log "Gathering #{repository_config['name'].cyan}"
-        build[vcs_repo.copied_to,
-              vcs_repo.full_name,
-              vcs_repo.copied?,
-              attributes['subnav_template'],
+        build[working_copy.copied_to,
+              working_copy.full_name,
+              working_copy.copied?,
+              section_config['subnav_template'],
               destination_dir,
-              vcs_repo.directory]
+              working_copy.directory]
       end
 
       private