bookbindery 1.0.3 → 2.0.0

data/lib/bookbinder/configuration_validator.rb

@@ -127,11 +127,31 @@ module Bookbinder
     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
+    end
+  end
+
   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
@@ -143,6 +163,7 @@ module Bookbinder
 
       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),

data/lib/bookbinder/distributor.rb

@@ -5,7 +5,7 @@ module Bookbinder
     EXPIRATION_HOURS = 2
 
     def self.build(logger, options)
-      namespace = GitHubRepository.new(logger: logger, full_name: options[:book_repo]).short_name
+      namespace = GitHubRepository.new(logger: logger, full_name: options[:book_repo], git_accessor: Git).short_name
       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)

data/lib/bookbinder/dita_html_to_middleman_formatter.rb

@@ -0,0 +1,37 @@
+module Bookbinder
+
+  class DitaHtmlToMiddlemanFormatter
+    def initialize(file_system_accessor)
+      @file_system_accessor = file_system_accessor
+    end
+
+    def format(src, dest)
+      all_files_with_ext = file_system_accessor.find_files_with_ext('.html', src)
+
+      all_files_with_ext.map do |filepath|
+        file_title_text = file_system_accessor.read_html_in_tag(path: filepath,
+                                                                marker: 'title')
+
+        file_body_text = file_system_accessor.read_html_in_tag(path: filepath,
+                                                               marker: 'body')
+
+        relative_path_to_file = file_system_accessor.relative_path_from(src, filepath)
+        new_filepath = File.join dest, "#{relative_path_to_file}.erb"
+
+        output_text = frontmatter(file_title_text) + file_body_text
+
+        file_system_accessor.write(to: new_filepath, text: output_text)
+      end
+    end
+
+    private
+
+    attr_reader :file_system_accessor
+
+    def frontmatter(title)
+      sanitized_title = title.gsub('"', '\"')
+      "---\ntitle: \"#{sanitized_title}\"\ndita: true\n---\n"
+    end
+
+  end
+end

data/lib/bookbinder/dita_section.rb

@@ -0,0 +1,7 @@
+module Bookbinder
+  DitaSection = Struct.new(:path_to_local_repo,
+                           :ditamap_location,
+                           :full_name,
+                           :target_ref,
+                           :directory)
+end

data/lib/bookbinder/dita_section_gatherer.rb

@@ -0,0 +1,28 @@
+module Bookbinder
+  class DitaSectionGatherer
+    def initialize(version_control_system, view_updater)
+      @version_control_system = version_control_system
+      @view_updater = view_updater
+    end
+
+    def gather(dita_sections, to: nil)
+      dita_sections.map do |dita_section|
+        view_updater.log "Gathering " + "#{dita_section.full_name}".cyan
+        version_control_system.clone("git@github.com:#{dita_section.full_name}",
+                                     dita_section.directory,
+                                     path: to)
+
+        DitaSection.new(File.join(to, dita_section.directory),
+                        dita_section.ditamap_location,
+                        dita_section.full_name,
+                        dita_section.target_ref,
+                        dita_section.directory)
+        end
+    end
+
+    private
+
+    attr_reader :version_control_system, :view_updater
+
+  end
+end

data/lib/bookbinder/git_accessor.rb

@@ -0,0 +1,17 @@
+require 'git'
+
+module Bookbinder
+  class GitAccessor
+    def initialize
+      @cache = {}
+    end
+
+    def clone(url, name, path: nil)
+      cache[[url, name, path]] ||= Git.clone(url, name, path: path)
+    end
+
+    private
+
+    attr_reader :cache, :third_party
+  end
+end

data/lib/bookbinder/git_client.rb

@@ -5,18 +5,21 @@ module Bookbinder
     class GitClient::TokenException < StandardError;
     end
 
-    def initialize(logger, *args)
-      @logger = logger
-      super(*args)
-    end
-
     def head_sha(full_name)
       commits(full_name).first.sha
     end
 
     def create_tag!(full_name, tagname, ref)
-      @logger.log 'Tagging ' + full_name.cyan
-      tag_result = create_tag(full_name, "tags/#{tagname}", 'Tagged by Bookbinder', ref, 'commit', 'Bookbinder', 'bookbinder@cloudfoundry.org', Time.now.iso8601)
+      tag_result = create_tag(
+        full_name,
+        "tags/#{tagname}",
+        'Tagged by Bookbinder',
+        ref,
+        'commit',
+        'Bookbinder',
+        'bookbinder@cloudfoundry.org',
+        Time.now.iso8601
+      )
       create_ref(full_name, "tags/#{tagname}", tag_result.sha)
     rescue Octokit::Unauthorized, Octokit::NotFound
       raise_error_with_context

data/lib/bookbinder/git_hub_repository.rb

@@ -1,52 +1,65 @@
-require 'ruby-progressbar'
 require 'bookbinder/shell_out'
 require 'git'
-require_relative 'git_client'
 require_relative 'bookbinder_logger'
+require_relative 'git_client'
 
 module Bookbinder
   class GitHubRepository
-    class RepositoryCloneError < StandardError
-      def initialize(msg=nil)
-        super
-      end
-    end
+    RepositoryCloneError = Class.new(StandardError)
 
     include Bookbinder::ShellOut
 
     attr_reader :full_name, :copied_to
 
-    def self.build_from_remote(logger, section_hash, destination_dir, target_ref, git_accessor)
+    def self.build_from_remote(logger,
+                               section_hash,
+                               target_ref,
+                               git_accessor)
       full_name = section_hash.fetch('repository', {}).fetch('name')
       target_ref = target_ref || section_hash.fetch('repository', {})['ref']
       directory = section_hash['directory']
-      repository = new(logger: logger, full_name: full_name, target_ref: target_ref, github_token: ENV['GITHUB_API_TOKEN'], directory: directory)
-      repository.copy_from_remote(destination_dir, git_accessor) if destination_dir
-      repository
-    end
-
-    def self.build_from_local(logger, section_hash, local_repo_dir, destination_dir)
+      new(logger: logger,
+          full_name: full_name,
+          target_ref: target_ref,
+          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']
 
-      repository = new(logger: logger, full_name: full_name, directory: directory, local_repo_dir: local_repo_dir)
-      repository.copy_from_local(destination_dir) if destination_dir
-
-      repository
+      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, target_ref: nil, github_token: nil, directory: nil, local_repo_dir: nil)
+    def initialize(logger: nil,
+                   full_name: nil,
+                   target_ref: nil,
+                   github_token: nil,
+                   directory: nil,
+                   local_repo_dir: nil,
+                   git_accessor: nil)
       @logger = logger
-      #TODO better error message
       raise 'No full_name provided ' unless full_name
       @full_name = full_name
-      @github = GitClient.new(logger, access_token: github_token || ENV['GITHUB_API_TOKEN'])
       @target_ref = target_ref
       @directory = directory
       @local_repo_dir = local_repo_dir
+
+      @github = GitClient.new(access_token: github_token || ENV['GITHUB_API_TOKEN'])
+      @git_accessor = git_accessor or raise ArgumentError.new("Must provide a git accessor")
     end
 
     def tag_with(tagname)
+      @logger.log 'Tagging ' + full_name.cyan
       @github.create_tag! full_name, tagname, head_sha
     end
 
@@ -62,9 +75,11 @@ module Bookbinder
       @directory || short_name
     end
 
-    def copy_from_remote(destination_dir, git_accessor = Git)
+    def copy_from_remote(destination_dir)
       begin
-        @git = git_accessor.clone("git@github.com:#{full_name}", directory, path: destination_dir)
+        @git_base_object = git_accessor.clone("git@github.com:#{full_name}",
+                                              directory,
+                                              path: destination_dir)
       rescue => e
         if e.message.include? "Permission denied (publickey)"
           raise RepositoryCloneError.new "Unable to access repository #{full_name}. You do not have the correct access rights. Please either add the key to your SSH agent, or set the GIT_SSH environment variable to override default SSH key usage. For more information run: `man git`."
@@ -75,8 +90,8 @@ module Bookbinder
           raise e
         end
       end
-      @git.checkout(target_ref) unless target_ref == 'master'
-      @copied_to = destination_dir
+      @git_base_object.checkout(target_ref) unless target_ref == 'master'
+      @copied_to = File.join(destination_dir, directory)
     end
 
     def copy_from_local(destination_dir)
@@ -116,30 +131,20 @@ module Bookbinder
       @logger.log '  skipping (not found) '.magenta + path_to_local_repo
     end
 
-    def get_modification_date_for(file: nil, git: nil)
-      @git ||= git
-      raise "Unexpected Error: Git accessor unavailable." if @git.nil?
-
-      irrelevant_path_component = directory+'/'
-      repo_path = file.gsub(irrelevant_path_component, '')
-
-      begin
-        @git.log(1).object(repo_path).first.date
-      rescue Git::GitExecuteError => e
-        raise "This file does not exist or is not tracked by git! Cannot get last modified date for #{repo_path}."
-      end
-    end
-
     def path_to_local_repo
-      File.join(@local_repo_dir, short_name)
+      if @local_repo_dir
+        File.join(@local_repo_dir, short_name)
+      end
     end
 
     def has_git_object?
-      !!@git
+      !!@git_base_object
     end
 
     private
 
+    attr_reader :git_accessor
+
     def target_ref
       @target_ref ||= 'master'
     end

data/lib/bookbinder/local_dita_preprocessor.rb

@@ -0,0 +1,27 @@
+module Bookbinder
+  class LocalDitaPreprocessor
+
+    def initialize(dita_converter, dita_formatter, local_file_system_accessor)
+      @dita_converter = dita_converter
+      @dita_formatter = dita_formatter
+      @local_file_system_accessor = local_file_system_accessor
+    end
+
+    def preprocess(dita_sections, converted_dita_dir, formatted_dita_dir, workspace_dir)
+      dita_converter.convert dita_sections, to: converted_dita_dir
+
+      dita_formatter.format converted_dita_dir, formatted_dita_dir
+
+      local_file_system_accessor.copy_named_directory_with_path('images',
+                                                                converted_dita_dir,
+                                                                workspace_dir)
+      local_file_system_accessor.copy_contents(formatted_dita_dir, workspace_dir)
+    end
+
+
+    private
+
+    attr_reader :dita_converter, :dita_formatter, :local_file_system_accessor
+
+  end
+end

data/lib/bookbinder/local_dita_to_html_converter.rb

@@ -0,0 +1,49 @@
+require_relative '../bookbinder/dita_section'
+
+module Bookbinder
+  class LocalDitaToHtmlConverter
+    DitaToHtmlLibraryFailure = Class.new(RuntimeError)
+
+    def initialize(sheller, path_to_dita_ot_library)
+      @sheller = sheller
+      @path_to_dita_ot_library = path_to_dita_ot_library
+    end
+
+    def convert(dita_sections, to: nil)
+      dita_sections.map do |dita_section|
+        absolute_path_to_ditamap = File.join dita_section.path_to_local_repo, dita_section.ditamap_location
+        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:" +
+                    "#{path_to_dita_ot_library}/lib/commons-codec-1.4.jar:" +
+                    "#{path_to_dita_ot_library}/lib/icu4j.jar:" +
+                    "#{path_to_dita_ot_library}/lib/saxon/saxon9-dom.jar:" +
+                    "#{path_to_dita_ot_library}/lib/saxon/saxon9.jar:target/classes:" +
+                    "#{path_to_dita_ot_library}:" +
+                    "#{path_to_dita_ot_library}/lib/:" +
+                    "#{path_to_dita_ot_library}/lib/dost.jar"
+        out_dir = File.join to, dita_section.directory
+        command = "export CLASSPATH=#{classpath}; " +
+                  "ant -f #{path_to_dita_ot_library} " +
+                  "-Dbasedir='/' " +
+                  "-Doutput.dir=#{out_dir} " +
+                  "-Dtranstype='tocjs' " +
+                  "-Dargs.input=#{absolute_path_to_ditamap} "
+
+        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
+      end
+    end
+
+    private
+
+    attr_reader :sheller, :path_to_dita_ot_library
+  end
+end

data/lib/bookbinder/local_file_system_accessor.rb

@@ -1,9 +1,77 @@
+require 'find'
+require 'pathname'
+require 'nokogiri'
+
 module Bookbinder
 
   class LocalFileSystemAccessor
     def file_exist?(path)
       File.exist?(path)
     end
+
+    def write(to: nil, text: nil)
+      make_directory(File.dirname to)
+
+      File.open(to, 'a') do |f|
+        f.write(text)
+      end
+
+      to
+    end
+
+    def read(path)
+      File.read(path)
+    end
+
+    def read_html_in_tag(path: nil, marker: nil)
+      doc = Nokogiri::XML(File.open path)
+      doc.css(marker).inner_html
+    end
+
+    def remove_directory(path)
+      FileUtils.rm_rf(path)
+    end
+
+    def make_directory(path)
+      FileUtils.mkdir_p(path)
+    end
+
+    def copy(src, dest)
+      FileUtils.cp_r src, dest
+    end
+
+    def copy_contents(src, dest)
+      contents = Dir.glob File.join(src, '**')
+      contents.each do |dir|
+        FileUtils.cp_r dir, dest
+      end
+    end
+
+    def copy_named_directory_with_path(dir_name, src, dest)
+      contents = Dir.glob File.join(src, "**/#{dir_name}")
+      contents.each do |dir|
+        relative_path_to_dir = relative_path_from(src, dir)
+        extended_dest = File.join dest, relative_path_to_dir
+        FileUtils.mkdir_p extended_dest
+        copy_contents dir, extended_dest
+      end
+    end
+
+    def rename_file(path, new_name)
+      new_path = File.expand_path File.join path, '..', new_name
+      File.rename(path, new_path)
+    end
+
+    def find_files_with_ext(ext, path)
+      Dir[File.join path, '**/*'].select { |file| File.basename(file).match(ext) }
+    end
+
+    def relative_path_from(src, target)
+      target_path = Pathname(File.absolute_path target)
+      relative_path = target_path.relative_path_from(Pathname(File.absolute_path src))
+      relative_path.to_s
+    end
+
   end
 
 end