bookbindery 3.0.1 → 3.1.0

data/lib/bookbinder/book.rb

@@ -1,59 +0,0 @@
-require_relative 'git_hub_repository'
-require_relative 'directory_helpers'
-
-module Bookbinder
-  class Book
-    include DirectoryHelperMethods
-
-    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)
-      book.copy_from_remote(destination_dir) if destination_dir
-      book
-    end
-
-    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
-
-      @target_ref = target_ref || 'master'
-
-      @repository = GitHubRepository.new(logger: logger,
-                                         full_name: full_name,
-                                         github_token: github_token,
-                                         git_accessor: git_accessor)
-      @git_accessor = git_accessor
-    end
-
-    def full_name
-      @repository.full_name
-    end
-
-    def head_sha
-      @repository.head_sha
-    end
-
-    def directory
-      @repository.directory
-    end
-
-    def copy_from_remote(destination_dir)
-      @repository.copy_from_remote(destination_dir, target_ref)
-    end
-
-    def tag_self_and_sections_with(tag)
-      (@section_vcs_repos + [@repository]).each { |repo| repo.tag_with tag }
-    end
-
-    private
-
-    attr_reader :target_ref
-  end
-end

data/lib/bookbinder/config/local_bind_configuration.rb

@@ -1,23 +0,0 @@
-module Bookbinder
-  module Config
-    class LocalBindConfiguration
-      def initialize(base_config)
-        @base_config = base_config
-      end
-
-      def to_h
-        {
-          sections: base_config.sections,
-          book_repo: base_config.book_repo,
-          host_for_sitemap: base_config.public_host,
-          archive_menu: base_config.archive_menu,
-          template_variables: base_config.template_variables
-        }
-      end
-
-      private
-
-      attr_reader :base_config
-    end
-  end
-end

data/lib/bookbinder/dita_preprocessor.rb

@@ -1,68 +0,0 @@
-require_relative 'values/subnav'
-
-module Bookbinder
-  class DitaPreprocessor
-
-    ACCEPTED_IMAGE_FORMATS = %w(png jpeg jpg svg gif bmp tif tiff eps)
-
-    def initialize(dita_formatter, local_fs_accessor)
-      @dita_formatter = dita_formatter
-      @local_fs_accessor = local_fs_accessor
-    end
-
-    def preprocess(dita_sections,
-                   subnavs_dir,
-                   dita_subnav_template_path,
-                   &block)
-      ditamap_location_sections = dita_sections.select { |dita_section| dita_section.ditamap_location }
-      ditamap_location_sections.each do |dita_section|
-        block.call(dita_section)
-        generate_subnav(dita_section, dita_subnav_template_path, subnavs_dir)
-      end
-
-      dita_sections.each do |dita_section|
-        dita_formatter.format_html dita_section.html_from_dita_section_dir, dita_section.formatted_section_dir
-
-        copy_images(dita_section.path_to_local_repo, dita_section.formatted_section_dir)
-
-        local_fs_accessor.copy_contents(dita_section.formatted_section_dir,
-                                        dita_section.section_source_for_site_generator)
-      end
-    end
-
-    private
-
-    attr_reader :dita_formatter, :local_fs_accessor
-
-    def generate_subnav(dita_section, dita_subnav_template_path, subnavs_dir)
-      dita_subnav_template_text = local_fs_accessor.read(dita_subnav_template_path)
-
-      tocjs_text = local_fs_accessor.read(File.join dita_section.html_from_dita_section_dir, 'index.html')
-      json_props_location = File.join('dita-subnav-props.json')
-      props_file_location = File.join(subnavs_dir, json_props_location)
-
-      subnav = dita_formatter.format_subnav(dita_section,
-                                            dita_subnav_template_text,
-                                            json_props_location,
-                                            tocjs_text)
-
-     local_fs_accessor.write text: subnav.json_links, to: props_file_location
-
-     local_fs_accessor.write text: subnav.text,
-                                       to: File.join(subnavs_dir, "dita_subnav.erb")
-    end
-
-    def copy_images(src, dest)
-      image_paths = ACCEPTED_IMAGE_FORMATS.map do |format|
-        local_fs_accessor.find_files_with_ext(format, src)
-      end.flatten
-
-      image_paths.each do |image_path|
-        local_fs_accessor.copy_including_intermediate_dirs(image_path,
-                                                           src,
-                                                           dest)
-      end
-    end
-
-  end
-end

data/lib/bookbinder/dita_section_gatherer_factory.rb

@@ -1,23 +0,0 @@
-require_relative 'local_dita_section_gatherer'
-require_relative 'remote_dita_section_gatherer'
-
-module Bookbinder
-  class DitaSectionGathererFactory
-    def initialize(version_control_system, view_updater)
-      @version_control_system = version_control_system
-      @view_updater = view_updater
-    end
-
-    def produce(source_location, output_locations)
-      if source_location == 'github'
-        RemoteDitaSectionGatherer.new(version_control_system, view_updater, output_locations)
-      else
-        LocalDitaSectionGatherer.new(output_locations)
-      end
-    end
-
-    private
-
-    attr_reader :version_control_system, :view_updater
-  end
-end

data/lib/bookbinder/git_client.rb

@@ -1,66 +0,0 @@
-require 'octokit'
-
-module Bookbinder
-  class GitClient < Octokit::Client
-    class GitClient::TokenException < StandardError;
-    end
-
-    def head_sha(full_name)
-      commits(full_name).first.sha
-    end
-
-    def create_tag!(full_name, tagname, ref)
-      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
-    end
-
-    def archive_link(*args)
-      super
-    rescue Octokit::Unauthorized, Octokit::NotFound
-      raise_error_with_context
-    end
-
-    def tags(*args)
-      super
-    rescue Octokit::Unauthorized, Octokit::NotFound
-      raise_error_with_context
-    end
-
-    def refs(*args)
-      super
-    rescue Octokit::Unauthorized, Octokit::NotFound
-      raise_error_with_context
-    end
-
-    def last_modified_date_of(full_name, target_ref, file)
-      commits = commits(full_name, target_ref, path: file)
-      commits.first[:commit][:author][:date]
-    end
-
-    private
-
-    def commits(*args)
-      super
-    rescue Octokit::Unauthorized, Octokit::NotFound
-      raise_error_with_context
-    end
-
-    def raise_error_with_context
-      absent_token_message = '  Cannot access repository! You must set $GITHUB_API_TOKEN.'
-      invalid_token_message = '  Cannot access repository! Does your $GITHUB_API_TOKEN have access to this repository? Does it exist?'
-
-      ENV['GITHUB_API_TOKEN'] ? raise(TokenException.new(invalid_token_message)) : raise(TokenException.new(absent_token_message))
-    end
-  end
-end

data/lib/bookbinder/git_hub_repository.rb

@@ -1,101 +0,0 @@
-require 'git'
-require_relative 'deprecated_logger'
-require_relative 'git_client'
-require_relative 'shell_out'
-
-module Bookbinder
-  class GitHubRepository
-    RepositoryCloneError = Class.new(StandardError)
-
-    include Bookbinder::ShellOut
-
-    attr_reader :full_name, :copied_to
-
-    def initialize(logger: nil,
-                   full_name: nil,
-                   github_token: nil,
-                   directory: nil,
-                   local_repo_dir: nil,
-                   git_accessor: nil)
-      @logger = logger
-      raise 'No full_name provided ' unless full_name
-      @full_name = full_name
-      @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
-
-    def short_name
-      full_name.split('/')[1]
-    end
-
-    def head_sha
-      @head_sha ||= @github.head_sha(full_name)
-    end
-
-    def directory
-      @directory || short_name
-    end
-
-    def copy_from_remote(destination_dir, target_ref)
-      begin
-        @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`."
-        elsif
-          e.message.include? "Repository not found."
-          raise RepositoryCloneError.new "Could not read from repository. Please make sure you have the correct access rights and the repository #{full_name} exists."
-        else
-          raise e
-        end
-      end
-      @git_base_object.checkout(target_ref) unless target_ref == 'master'
-      @copied_to = File.join(destination_dir, directory)
-    end
-
-    def copied?
-      !@copied_to.nil?
-    end
-
-    def has_tag?(tagname)
-      tags.any? { |tag| tag.name == tagname }
-    end
-
-    def update_local_copy
-      if File.exist?(path_to_local_repo)
-        @logger.log 'Updating ' + path_to_local_repo.cyan
-        Kernel.system("cd #{path_to_local_repo} && git pull")
-      else
-        announce_skip
-      end
-    end
-
-    def announce_skip
-      @logger.log '  skipping (not found) '.magenta + path_to_local_repo
-    end
-
-    private
-
-    attr_reader :git_accessor
-
-    def path_to_local_repo
-      if @local_repo_dir
-        File.join(@local_repo_dir, short_name)
-      end
-    end
-
-    def tags
-      @github.tags @full_name
-    end
-  end
-end

data/lib/bookbinder/local_dita_section_gatherer.rb

@@ -1,32 +0,0 @@
-module Bookbinder
-  class LocalDitaSectionGatherer
-    def initialize(output_locations)
-      @output_locations = output_locations
-    end
-
-    def gather(dita_section_config_hash)
-      dita_section_config_hash.map do |dita_section_config|
-        relative_path_to_dita_map = dita_section_config['ditamap_location']
-        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']
-        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,
-                        desired_destination_directory_name,
-                        output_locations)
-      end
-    end
-
-    private
-
-    attr_reader :output_locations
-
-  end
-end

data/lib/bookbinder/remote_dita_section_gatherer.rb

@@ -1,35 +0,0 @@
-require_relative '../../lib/bookbinder/deprecated_logger'
-require_relative '../../lib/bookbinder/values/dita_section'
-
-module Bookbinder
-  class RemoteDitaSectionGatherer
-    def initialize(version_control_system, view_updater, output_locations)
-      @version_control_system = version_control_system
-      @view_updater = view_updater
-      @cloned_dita_dir = output_locations.cloned_dita_dir
-      @output_locations = output_locations
-    end
-
-    def gather(dita_section_config_hash)
-      dita_section_config_hash.map do |dita_section_config|
-        view_updater.log "Gathering " + "#{dita_section_config.fetch('repository', {}).fetch('name')}".cyan
-        version_control_system.clone("git@github.com:#{dita_section_config.fetch('repository', {}).fetch('name')}",
-                                     dita_section_config['directory'],
-                                     path: cloned_dita_dir)
-
-        DitaSection.new(cloned_dita_dir.join(dita_section_config['directory']),
-                        dita_section_config['ditamap_location'],
-                        dita_section_config['ditaval_location'],
-                        dita_section_config.fetch('repository', {}).fetch('name'),
-                        dita_section_config.fetch('repository', {})['ref'],
-                        dita_section_config['directory'],
-                        output_locations)
-      end
-    end
-
-    private
-
-    attr_reader :version_control_system, :view_updater, :cloned_dita_dir, :output_locations
-
-  end
-end

data/lib/bookbinder/validation_checkers/config_version_checker.rb

@@ -1,91 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require_relative '../configuration'
-
-module Bookbinder
-  class ConfigVersionChecker
-    def initialize(bookbinder_schema_version, starting_schema_version, messages, view_updater)
-      @bookbinder_schema_version = bookbinder_schema_version
-      @starting_schema_version = starting_schema_version
-      @messages = messages
-      @view_updater = view_updater
-    end
-
-    def check(config)
-      user_schema_version = Version.parse(config['schema_version'])
-      if user_schema_version.valid?
-        if user_schema_version.major > bookbinder_schema_version.major
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.minor > bookbinder_schema_version.minor
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.patch > bookbinder_schema_version.patch
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.unrecognized_schema_version_message
-        elsif user_schema_version.major < bookbinder_schema_version.major
-          raise Configuration::ConfigSchemaUnsupportedError.new messages.incompatible_schema_message
-        elsif user_schema_version.minor < bookbinder_schema_version.minor
-          view_updater.warn nonbreaking_schema_message_for("minor")
-        elsif user_schema_version.patch < bookbinder_schema_version.patch
-          view_updater.warn nonbreaking_schema_message_for("patch")
-        end
-      elsif bookbinder_schema_version != starting_schema_version
-        raise Configuration::ConfigSchemaUnsupportedError.new messages.schema_now_required_message
-      end
-    end
-
-    private
-
-    attr_reader :bookbinder_schema_version, :starting_schema_version, :messages, :view_updater
-
-    def nonbreaking_schema_message_for(version_level)
-      "[WARNING] Your schema is valid, but there exists a new #{version_level} version. Consider updating your config.yml."
-    end
-  end
-
-  Version = Struct.new(:major, :minor, :patch) do
-    class << self
-      def parse(raw_version)
-        if raw_version
-          new(*raw_version.split('.'))
-        else
-          new(nil, nil, nil)
-        end
-      end
-    end
-
-    def valid?
-      [major, minor, patch].all?(&:present?)
-    end
-
-    def to_s
-      [major, minor, patch].compact.join('.')
-    end
-  end
-
-  class VersionCheckerMessages
-    def initialize(user_schema_version, bookbinder_schema_version)
-      @user_schema_version = user_schema_version
-      @bookbinder_schema_version = bookbinder_schema_version
-    end
-
-    def schema_now_required_message
-      "[ERROR] Bookbinder now requires a certain schema. Please see README " +
-          "and provide a schema version."
-    end
-
-    def incompatible_schema_message
-      "[ERROR] Your config.yml format, schema version #{user_schema_version}, " +
-          "is older than this version of Bookbinder can support. Please update " +
-          "your config.yml keys and format to version #{bookbinder_schema_version} " +
-          "and try again."
-    end
-
-    def unrecognized_schema_version_message
-      "[ERROR] The config schema version #{user_schema_version} is " +
-          "unrecognized by this version of Bookbinder. The latest schema version " +
-          "is #{bookbinder_schema_version}."
-    end
-
-    private
-
-    attr_reader :user_schema_version, :bookbinder_schema_version
-  end
-end