bookbindery 1.0.3 → 2.0.0

data/lib/bookbinder/middleman_runner.rb

@@ -2,11 +2,12 @@ require 'middleman-core'
 require 'middleman-core/cli'
 require 'middleman-core/profiling'
 require_relative 'code_example'
+require_relative 'code_example_reader'
 
 class Middleman::Cli::BuildAction
   def handle_error(file_name, response, e=Thor::Error.new(response))
     our_errors = [Bookbinder::GitClient::TokenException,
-                  Bookbinder::CodeExample::InvalidSnippet,
+                  Bookbinder::CodeExampleReader::InvalidSnippet,
                   QuicklinksRenderer::BadHeadingLevelError,
                   Git::GitExecuteError]
     raise e if our_errors.include?(e.class)
@@ -31,20 +32,36 @@ end
 
 module Bookbinder
   class MiddlemanRunner
-    def initialize(logger)
+    def initialize(logger, git_accessor)
       @logger = logger
+      @git_accessor = git_accessor
     end
 
-    def run(middleman_dir, template_variables, local_repo_dir, verbose = false, book = nil, sections = [], production_host=nil, archive_menu=nil, git_accessor=Git)
+    def run(middleman_dir,
+            workspace_dir,
+            template_variables,
+            local_repo_dir,
+            verbose = false,
+            subnav_templates_by_directory = {},
+            production_host=nil,
+            archive_menu=nil)
       @logger.log "\nRunning middleman...\n\n"
 
       within(middleman_dir) do
-        invoke_against_current_dir(local_repo_dir, production_host, book, sections, template_variables, archive_menu, verbose, git_accessor)
+        invoke_against_current_dir(local_repo_dir,
+                                   workspace_dir,
+                                   production_host,
+                                   subnav_templates_by_directory,
+                                   template_variables,
+                                   archive_menu,
+                                   verbose)
       end
     end
 
     private
 
+    attr_reader :git_accessor
+
     def within(temp_root, &block)
       Middleman::Cli::Build.instance_variable_set(:@_shared_instance, nil)
       original_mm_root  = ENV['MM_ROOT']
@@ -55,32 +72,28 @@ module Bookbinder
       ENV['MM_ROOT']    = original_mm_root
     end
 
-    def invoke_against_current_dir(local_repo_dir, production_host, book, sections, template_variables, archive_menu, verbose, git_accessor)
+    def invoke_against_current_dir(local_repo_dir,
+                                   workspace_dir,
+                                   production_host,
+                                   subnav_templates,
+                                   template_variables,
+                                   archive_menu,
+                                   verbose)
       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,
-          sections: sections,
-          book: book,
           template_variables: template_variables,
           relative_links: false,
-          subnav_templates: subnavs_by_dir_name(sections),
+          subnav_templates: subnav_templates,
           archive_menu: archive_menu
       }
 
       config.each { |k, v| builder.config[k] = v }
       Middleman::Cli::Build.new([], {quiet: !verbose}, {}).invoke :build, [], {verbose: verbose}
     end
-
-    def subnavs_by_dir_name(sections)
-      sections.reduce({}) do |final_map, section|
-        namespace = section.directory.gsub('/', '_')
-        template = section.subnav_template || 'default'
-
-        final_map.merge(namespace => template)
-      end
-    end
   end
 end

data/lib/bookbinder/publisher.rb

@@ -1,43 +1,35 @@
 require 'middleman-syntax'
 require_relative 'bookbinder_logger'
 require_relative 'directory_helpers'
-require_relative 'section'
+require_relative 'repositories/section_repository'
 require_relative 'server_director'
 
 module Bookbinder
   class Publisher
     include DirectoryHelperMethods
 
-    def initialize(logger, spider, static_site_generator)
-      @gem_root = File.expand_path('../../../', __FILE__)
+    def initialize(logger, spider, static_site_generator, server_director, file_system_accessor)
       @logger = logger
       @spider = spider
       @static_site_generator = static_site_generator
+      @server_director = server_director
+      @file_system_accessor = file_system_accessor
     end
 
-    def publish(cli_options, output_paths, publish_config, git_accessor)
+    def publish(subnavs, cli_options, output_paths, publish_config)
       intermediate_directory = output_paths.fetch(:output_dir)
       final_app_dir = output_paths.fetch(:final_app_dir)
-      master_middleman_dir = output_paths.fetch(:master_middleman_dir)
       master_dir = File.join intermediate_directory, 'master_middleman'
       workspace_dir = File.join master_dir, 'source'
       build_directory = File.join master_dir, 'build/.'
       public_directory = File.join final_app_dir, 'public'
 
-      @versions = publish_config.fetch(:versions, [])
-      @book_repo = publish_config[:book_repo]
-      prepare_directories final_app_dir, intermediate_directory, workspace_dir, master_middleman_dir, master_dir, git_accessor
       FileUtils.cp 'redirects.rb', final_app_dir if File.exists?('redirects.rb')
 
-      target_tag = cli_options[:target_tag]
-      sections = gather_sections(workspace_dir, publish_config, output_paths, target_tag, git_accessor)
-      book = Book.new(logger: @logger,
-                      full_name: @book_repo,
-                      sections: publish_config.fetch(:sections))
       host_for_sitemap = publish_config.fetch(:host_for_sitemap)
 
-      generate_site(cli_options, output_paths, publish_config, master_dir, book, sections, build_directory, public_directory, git_accessor)
-      generate_sitemap(final_app_dir, host_for_sitemap, @spider)
+      generate_site(cli_options, output_paths, publish_config, master_dir, workspace_dir, subnavs, build_directory, public_directory)
+      generate_sitemap(host_for_sitemap, @spider)
 
       @logger.log "Bookbinder bound your book into #{final_app_dir.to_s.green}"
 
@@ -46,80 +38,24 @@ module Bookbinder
 
     private
 
-    def generate_sitemap(final_app_dir, host_for_sitemap, spider)
-      server_director = ServerDirector.new(@logger, directory: final_app_dir)
+    attr_reader :section_repository, :logger, :file_system_accessor
+
+    def generate_sitemap(host_for_sitemap, spider)
       raise "Your public host must be a single String." unless host_for_sitemap.is_a?(String)
 
-      server_director.use_server { |port| spider.generate_sitemap host_for_sitemap, port }
+      @server_director.use_server { |port| spider.generate_sitemap host_for_sitemap, port }
     end
 
-    def generate_site(cli_options, output_paths, publish_config, middleman_dir, book, sections, build_dir, public_dir, git_accessor)
+    def generate_site(cli_options, output_paths, publish_config, middleman_dir, workspace_dir, subnavs, build_dir, public_dir)
       @static_site_generator.run(middleman_dir,
+                                 workspace_dir,
                                  publish_config.fetch(:template_variables, {}),
                                  output_paths[:local_repo_dir],
                                  cli_options[:verbose],
-                                 book,
-                                 sections,
+                                 subnavs,
                                  publish_config[:host_for_sitemap],
-                                 publish_config[:archive_menu],
-                                 git_accessor
-      )
-      FileUtils.cp_r build_dir, public_dir
-    end
-
-    def gather_sections(workspace, publish_config, output_paths, target_tag, git_accessor)
-      section_data = publish_config.fetch(:sections)
-      section_data.map do |attributes|
-        section = Section.get_instance(@logger,
-                                       section_hash: attributes,
-                                       destination_dir: workspace,
-                                       local_repo_dir: output_paths[:local_repo_dir],
-                                       target_tag: target_tag,
-                                       git_accessor: git_accessor)
-        section
-      end
-    end
-
-    def prepare_directories(final_app, middleman_scratch_space, middleman_source, master_middleman_dir, middleman_dir, git_accessor)
-      forget_sections(middleman_scratch_space)
-      FileUtils.rm_rf File.join final_app, '.'
-      FileUtils.mkdir_p middleman_scratch_space
-      FileUtils.mkdir_p File.join final_app, 'public'
-      FileUtils.mkdir_p middleman_source
-
-      copy_directory_from_gem 'template_app', final_app
-      copy_directory_from_gem 'master_middleman', middleman_dir
-      FileUtils.cp_r File.join(master_middleman_dir, '.'), middleman_dir
-
-      copy_version_master_middleman(middleman_source, git_accessor)
-    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, git_accessor)
-      @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: git_accessor)
-          index_source_dir = File.join(tmpdir, book.directory, 'master_middleman', source_dir_name)
-          index_dest_dir = File.join(dest_dir, version)
-          FileUtils.mkdir_p(index_dest_dir)
-
-          Dir.glob(File.join(index_source_dir, 'index.*')) do |f|
-            FileUtils.cp(File.expand_path(f), index_dest_dir)
-          end
-        end
-      end
-    end
-
-    def forget_sections(middleman_scratch)
-      Section.store.clear
-      FileUtils.rm_rf File.join middleman_scratch, '.'
-    end
-
-    def copy_directory_from_gem(dir, output_dir)
-      FileUtils.cp_r File.join(@gem_root, "#{dir}/."), output_dir
+                                 publish_config[:archive_menu])
+      file_system_accessor.copy build_dir, public_dir
     end
   end
 end

data/lib/bookbinder/remote_yaml_credential_provider.rb

@@ -3,16 +3,15 @@ require 'tempfile'
 
 module Bookbinder
   class RemoteYamlCredentialProvider
-    def initialize(logger, repository, git_accessor = Git)
+    def initialize(logger, repository)
       @logger = logger
       @repository = repository
-      @git_accessor = git_accessor
     end
 
     def credentials
       @logger.log "Processing #{@repository.full_name.cyan}"
       Dir.mktmpdir do |destination_dir|
-        @repository.copy_from_remote(destination_dir, @git_accessor)
+        @repository.copy_from_remote(destination_dir)
         cred_file_yaml = File.join(destination_dir, @repository.short_name, 'credentials.yml')
         YAML.load_file(cred_file_yaml)
       end

data/lib/bookbinder/repositories/command_repository.rb

@@ -0,0 +1,156 @@
+Dir.glob(File.expand_path('../../commands/*.rb', __FILE__)).each do |command_file|
+  require command_file
+end
+require_relative '../configuration_fetcher'
+require_relative '../configuration_validator'
+require_relative '../dita_html_to_middleman_formatter'
+require_relative '../git_accessor'
+require_relative '../local_dita_to_html_converter'
+require_relative '../local_dita_preprocessor'
+require_relative '../local_file_system_accessor'
+require_relative '../middleman_runner'
+require_relative '../spider'
+require_relative '../yaml_loader'
+
+module Bookbinder
+  module Repositories
+    class CommandRepository
+      include Enumerable
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def each(&block)
+        list.each(&block)
+      end
+
+      def help
+        @help ||= Commands::Help.new(
+          logger,
+          [version] + standard_commands
+        )
+      end
+
+      private
+
+      attr_reader :logger
+
+      def list
+        standard_commands + flags
+      end
+
+      def flags
+        @flags ||= [ version, help ]
+      end
+
+      def standard_commands
+        @standard_commands ||= [
+          build_and_push_tarball,
+          Commands::GeneratePDF.new(logger, configuration_fetcher),
+          bind,
+          push_local_to_staging,
+          Commands::PushToProd.new(logger, configuration_fetcher),
+          Commands::RunPublishCI.new(bind, push_local_to_staging, build_and_push_tarball),
+          Commands::Tag.new(logger, configuration_fetcher),
+          Commands::UpdateLocalDocRepos.new(logger, configuration_fetcher),
+        ]
+      end
+
+      def version
+        @version ||= Commands::Version.new(logger)
+      end
+
+      def bind
+        @bind ||= Commands::Bind.new(
+          logger,
+          configuration_fetcher,
+          ArchiveMenuConfiguration.new(
+            loader: config_loader,
+            config_filename: 'bookbinder.yml'
+          ),
+          git_accessor,
+          local_file_system_accessor,
+          middleman_runner,
+          spider,
+          final_app_directory,
+          server_director,
+          File.absolute_path('.'),
+          dita_preprocessor
+        )
+      end
+
+      def push_local_to_staging
+        @push_local_to_staging ||= Commands::PushLocalToStaging.new(
+          logger,
+          configuration_fetcher
+        )
+      end
+
+      def build_and_push_tarball
+        @build_and_push_tarball ||= Commands::BuildAndPushTarball.new(
+          logger,
+          configuration_fetcher
+        )
+      end
+
+      def spider
+        @spider ||= Spider.new(logger, app_dir: final_app_directory)
+      end
+
+      def server_director
+        @server_director ||= ServerDirector.new(
+          logger,
+          directory: final_app_directory
+        )
+      end
+
+      def middleman_runner
+        @middleman_runner ||= MiddlemanRunner.new(logger, git_accessor)
+      end
+
+      def configuration_fetcher
+        @configuration_fetcher ||= ConfigurationFetcher.new(
+          logger,
+          ConfigurationValidator.new(logger, local_file_system_accessor),
+          config_loader
+        ).tap do |fetcher|
+          fetcher.set_config_file_path './config.yml'
+        end
+      end
+
+      def config_loader
+        @config_loader ||= YAMLLoader.new
+      end
+
+      def final_app_directory
+        @final_app_directory ||= File.absolute_path('final_app')
+      end
+
+      def dita_preprocessor
+        @dita_preprocessor ||=
+            LocalDitaPreprocessor.new(local_dita_processor,
+                                 dita_html_to_middleman_formatter,
+                                 local_file_system_accessor)
+      end
+
+      def local_dita_processor
+        @local_dita_processor ||=
+            LocalDitaToHtmlConverter.new(Sheller.new(logger),
+                                         ENV['PATH_TO_DITA_OT_LIBRARY'])
+      end
+
+      def dita_html_to_middleman_formatter
+        @dita_html_to_middleman_formatter ||= DitaHtmlToMiddlemanFormatter.new(local_file_system_accessor)
+      end
+
+      def git_accessor
+        @git_accessor ||= GitAccessor.new
+      end
+
+      def local_file_system_accessor
+        @local_file_system_accessor ||= LocalFileSystemAccessor.new
+      end
+    end
+  end
+end

data/lib/bookbinder/repositories/section_repository.rb

@@ -0,0 +1,31 @@
+require 'tmpdir'
+
+module Bookbinder
+  module Repositories
+    class SectionRepository
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def get_instance(attributes,
+                       vcs_repo: nil,
+                       destination_dir: Dir.mktmpdir,
+                       build: nil)
+        repository_config = attributes['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'],
+              destination_dir,
+              vcs_repo.directory]
+      end
+
+      private
+
+      attr_reader :logger
+    end
+  end
+end

data/lib/bookbinder/section.rb

@@ -1,78 +1,16 @@
-require 'bookbinder/directory_helpers'
-
 module Bookbinder
-  class Section
-
-    def self.store
-      @@store ||= {}
-    end
-
-    def self.get_instance(logger,
-                          section_hash: {},
-                          local_repo_dir: nil,
-                          destination_dir: Dir.mktmpdir,
-                          target_tag: nil,
-                          git_accessor: Git)
-      @git_accessor = git_accessor
-      store.fetch([section_hash, local_repo_dir]) { acquire(logger, section_hash, local_repo_dir, destination_dir, target_tag, git_accessor) }
-    end
 
-    def initialize(logger, repository, subnav_template)
-      @logger = logger
-      @subnav_template = subnav_template
-      @repository = repository
-      @git_accessor = Git
+  Section = Struct.new(:path_to_repository, :full_name, :copied, :subnav_templ, :destination_dir, :directory_name) do
+    def path_to_repository
+      Pathname(self[:path_to_repository].to_s)
     end
 
     def subnav_template
-      @subnav_template.gsub(/^_/, '').gsub(/\.erb$/, '') if @subnav_template
+      subnav_templ.sub(/^_/, '').sub(/\.erb$/, '') if subnav_templ
     end
 
     def directory
-      @repository.directory
-    end
-
-    def full_name
-      @repository.full_name
-    end
-
-    def copied?
-      @repository.copied?
-    end
-
-    def get_modification_date_for(file: nil, full_path: nil)
-      unless @repository.has_git_object?
-        begin
-          git_base_object = @git_accessor.open(@repository.path_to_local_repo)
-        rescue => e
-          raise "Invalid git repository! Cannot get modification date for section: #{@repository.path_to_local_repo}."
-        end
-      end
-      @repository.get_modification_date_for(file: file, git: git_base_object)
-    end
-
-    private
-
-    def self.acquire(logger, section_hash, local_repo_dir, destination, target_tag, git_accessor)
-      repository = section_hash['repository']
-      raise "section repository '#{repository}' is not a hash" unless repository.is_a?(Hash)
-      raise "section repository '#{repository}' missing name key" unless repository['name']
-      logger.log "Gathering #{repository['name'].cyan}"
-
-      repository = build_repository(logger, destination, local_repo_dir, section_hash, target_tag, git_accessor)
-      section = new(logger, repository, section_hash['subnav_template'])
-
-      store[[section_hash, local_repo_dir]] = section
-    end
-    private_class_method :acquire
-
-    def self.build_repository(logger, destination, local_repo_dir, repo_hash, target_tag, git_accessor)
-      if local_repo_dir
-        GitHubRepository.build_from_local(logger, repo_hash, local_repo_dir, destination)
-      else
-        GitHubRepository.build_from_remote(logger, repo_hash, destination, target_tag, git_accessor)
-      end
+      directory_name
     end
-    private_class_method :build_repository
   end
 end