bookbindery 3.0.1 → 3.1.0

data/lib/bookbinder/commands/help.rb

@@ -44,7 +44,7 @@ module Bookbinder
       end
 
       def chars_for_usage_definition
-        33
+        72
       end
 
       def flags

data/lib/bookbinder/commands/run_publish_ci.rb

@@ -22,10 +22,8 @@ module Bookbinder
       end
 
       def run(cli_args)
-        raise BuildAndPushTarball::MissingBuildNumber unless ENV['BUILD_NUMBER']
-
         command_chain(
-          ->{publish_command.run(['github'] + cli_args)},
+          ->{publish_command.run(['remote'] + cli_args)},
           ->{push_local_to_staging_command.run([])},
           ->{build_and_push_tarball_command.run([])}
         )

data/lib/bookbinder/commands/tag.rb

@@ -1,4 +1,3 @@
-require_relative '../book'
 require_relative '../deprecated_logger'
 require_relative '../errors/cli_error'
 require_relative 'naming'
@@ -8,31 +7,35 @@ module Bookbinder
     class Tag
       include Commands::Naming
 
-      def initialize(logger, configuration_fetcher)
+      def initialize(logger, configuration_fetcher, version_control_system)
         @logger = logger
         @configuration_fetcher = configuration_fetcher
+        @version_control_system = version_control_system
       end
 
       def usage
         ["tag <git tag>", "Apply the specified <git tag> to your book and all sections of your book"]
       end
 
-      def run(params)
-        tag = params.first
+      def run((tag, *))
         raise CliError::InvalidArguments unless tag
 
-        book = Book.new(logger: @logger, full_name: config.book_repo, sections: config.sections)
-
-        book.tag_self_and_sections_with tag
+        urls(config).each do |url|
+          version_control_system.remote_tag(url, tag, 'HEAD')
+        end
 
         @logger.log 'Success!'.green
-        @logger.log " #{book.full_name.yellow} and its sections were tagged with #{tag.blue}"
+        @logger.log " #{config.book_repo.yellow} and its sections were tagged with #{tag.blue}"
         0
       end
 
       private
 
-      attr_reader :configuration_fetcher
+      attr_reader :configuration_fetcher, :version_control_system
+
+      def urls(config)
+        [config.book_repo_url] + config.sections.map(&:repo_url).uniq
+      end
 
       def config
         @config ||= configuration_fetcher.fetch_config

data/lib/bookbinder/commands/update_local_doc_repos.rb

@@ -1,27 +1,43 @@
-require_relative 'bookbinder_command'
+require_relative '../deprecated_logger'
+require_relative '../ingest/destination_directory'
 require_relative 'naming'
 
 module Bookbinder
   module Commands
-    class UpdateLocalDocRepos < BookbinderCommand
+    class UpdateLocalDocRepos
       include Commands::Naming
 
+      def initialize(logger, configuration_fetcher, version_control_system, filesystem)
+        @logger = logger
+        @configuration_fetcher = configuration_fetcher
+        @version_control_system = version_control_system
+        @filesystem = filesystem
+      end
+
       def usage
         [command_name,
          "Run `git pull` on all sections that exist at the same directory level as your book directory"]
       end
 
       def run(_)
-        config.sections.map { |conf| repo_for(conf) }.each(&:update_local_copy)
+        urls = configuration_fetcher.fetch_config.sections.map(&:repo_url)
+        paths(urls).each do |path|
+          if filesystem.file_exist?(path)
+            logger.log 'Updating ' + path.cyan
+            version_control_system.update(path)
+          else
+            logger.log '  skipping (not found) '.magenta + path
+          end
+        end
         0
       end
 
       private
 
-      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, git_accessor: Git)
+      attr_reader :logger, :configuration_fetcher, :version_control_system, :filesystem
+
+      def paths(urls)
+        urls.map {|url| File.absolute_path("../#{Ingest::DestinationDirectory.new(url)}")}
       end
     end
   end

data/lib/bookbinder/config/bind_config_factory.rb

@@ -1,20 +1,18 @@
-require_relative 'local_bind_configuration'
 require_relative 'remote_bind_configuration'
 
 module Bookbinder
   module Config
     class BindConfigFactory
-      def initialize(logger, version_control_system, config_fetcher)
-        @logger = logger
+      def initialize(version_control_system, config_fetcher)
         @version_control_system = version_control_system
         @config_fetcher = config_fetcher
       end
 
       def produce(bind_source)
-        if bind_source == 'github' && config.has_option?('versions')
-          RemoteBindConfiguration.new(logger, version_control_system, config).to_h
+        if %w(remote github).include?(bind_source) && config.has_option?('versions')
+          RemoteBindConfiguration.new(version_control_system, config).fetch
         else
-          LocalBindConfiguration.new(config).to_h
+          config
         end
       end
 
@@ -24,7 +22,7 @@ module Bookbinder
         config_fetcher.fetch_config
       end
 
-      attr_reader :logger, :version_control_system, :config_fetcher
+      attr_reader :version_control_system, :config_fetcher
     end
   end
 end

data/lib/bookbinder/config/remote_bind_configuration.rb

@@ -1,50 +1,42 @@
+require 'yaml'
+require_relative '../ingest/destination_directory'
+
 module Bookbinder
   module Config
     class RemoteBindConfiguration
       VersionUnsupportedError = Class.new(RuntimeError)
 
-      def initialize(logger, version_control_system, base_config)
-        @logger = logger
+      def initialize(version_control_system, base_config)
         @version_control_system = version_control_system
         @base_config = base_config
       end
 
-      def to_h
-        sections = base_config.sections
-        base = {
-          sections: sections,
-          book_repo: base_config.book_repo,
-          host_for_sitemap: base_config.public_host,
-          archive_menu: base_config.archive_menu,
-          versions: base_config.versions,
-          template_variables: base_config.template_variables
-        }
-        base_config.versions.each { |version| sections.concat(sections_from(version)) }
-        base
+      def fetch
+        base_config.merge_sections(base_config.versions.flat_map { |version| sections_from(version) })
       end
 
       private
 
-      attr_reader :logger, :version_control_system, :base_config
+      attr_reader :version_control_system, :base_config
 
       def sections_from(version)
-        Dir.mktmpdir('book_checkout') do |temp_workspace|
-          book = Book.from_remote(logger: logger,
-                                  full_name: base_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?
+        sections = Configuration.parse(
+          YAML.load(
+          version_control_system.read_file(
+            'config.yml',
+            from_repo: base_config.book_repo_url,
+            checkout: version
+          )
+        )).sections
+        raise VersionUnsupportedError.new(version) if sections.empty?
 
-          attrs.map do |section_hash|
-            section_hash['repository']['ref'] = version
-            section_hash['directory'] = File.join(version, section_hash['directory'])
-            section_hash
-          end
+        sections.map do |section|
+          section.merge(
+            Config::SectionConfig.new(
+              'repository' => { 'name' => section.repo_name, 'ref' => version },
+              'directory' => File.join(version, section.desired_directory_name)
+            )
+          )
         end
       end
     end

data/lib/bookbinder/config/section_config.rb

@@ -0,0 +1,56 @@
+require_relative '../ingest/repo_identifier'
+
+module Bookbinder
+  module Config
+    class SectionConfig
+      def initialize(config)
+        @config = config
+      end
+
+      def subnav_template
+        config['subnav_template']
+      end
+
+      def desired_directory_name
+        config['directory']
+      end
+
+      def repo_name
+        repo['name']
+      end
+
+      def repo_url
+        Ingest::RepoIdentifier.new(repo['name'])
+      end
+
+      def repo_ref
+        repo['ref'] || 'master'
+      end
+
+      def preprocessor_config
+        config['preprocessor_config']
+      end
+
+      def ==(other)
+        config == other.instance_variable_get(:@config)
+      end
+
+      def merge(other_section_config)
+        SectionConfig.new(config.merge(other_section_config.instance_variable_get(:@config)))
+      end
+
+      def inspect
+        config.inspect
+      end
+
+      private
+
+      def repo
+        config['repository']
+      end
+
+      attr_reader :config
+    end
+  end
+end
+

data/lib/bookbinder/configuration.rb

@@ -1,47 +1,87 @@
+require_relative 'ingest/repo_identifier'
+require_relative 'config/section_config'
+
 module Bookbinder
   class Configuration
+    class << self
+      def parse(input_config)
+        new(symbolize_keys(input_config).
+            merge(expand_repo_identifiers(input_config)).
+            merge(sections: combined_sections(input_config)))
+      end
 
-    CURRENT_SCHEMA_VERSION = '1.0.0'
-    STARTING_SCHEMA_VERSION = '1.0.0'
+      private
 
-    ConfigSchemaUnsupportedError = Class.new(RuntimeError)
+      def symbolize_keys(h)
+        h.reduce({}) {|acc, (k, v)| acc.merge(k.to_sym => v) }
+      end
 
-    attr_reader :schema_version, :schema_major_version, :schema_minor_version, :schema_patch_version
+      def expand_repo_identifiers(input_config)
+        input_config.select {|k, _| k.match(/_repo$/)}.
+          reduce({}) {|h, (k, v)| h.merge(:"#{k}_url" => Ingest::RepoIdentifier.new(v))}
+      end
 
-    def initialize(logger, config_hash)
-      @logger = logger
-      @config = config_hash
+      def combined_sections(input_config)
+        (regular_sections(input_config) + dita_sections(input_config)).
+          map { |section| Config::SectionConfig.new(section) }
+      end
+
+      def regular_sections(input_config)
+        input_config['sections'] || []
+      end
+
+      def dita_sections(input_config)
+        (input_config['dita_sections'] || []).map { |dita_section|
+          dita_section.merge(
+            'preprocessor_config' => {
+              'ditamap_location' => dita_section['ditamap_location'],
+              'ditaval_location' => dita_section['ditaval_location']
+            },
+            'subnav_template' => 'dita_subnav'
+          ).reject { |k, _|
+            %w(ditamap_location ditaval_location).include?(k)
+          }
+        }
+      end
+    end
+
+    def initialize(config)
+      @config = config
     end
 
     CONFIG_REQUIRED_KEYS = %w(book_repo public_host)
-    CONFIG_OPTIONAL_KEYS = %w(archive_menu layout_repo versions cred_repo)
+    CONFIG_OPTIONAL_KEYS = %w(archive_menu book_repo_url cred_repo cred_repo_url layout_repo layout_repo_url sections)
 
     CONFIG_REQUIRED_KEYS.each do |method_name|
       define_method(method_name) do
-        config.fetch(method_name)
+        config.fetch(method_name.to_sym)
       end
     end
 
     CONFIG_OPTIONAL_KEYS.each do |method_name|
       define_method(method_name) do
-        config[method_name]
+        config[method_name.to_sym]
       end
     end
 
-    def sections
-      config.fetch('sections', [])
+    def template_variables
+      config.fetch(:template_variables, {})
     end
 
-    def dita_sections
-      config.fetch('dita_sections', {})
+    def versions
+      config.fetch(:versions, [])
     end
 
-    def has_option?(key)
-      @config.has_key?(key)
+    def merge(other_configuration)
+      Configuration.new(config.merge(other_configuration.instance_variable_get(:@config)))
     end
 
-    def template_variables
-      config.fetch('template_variables', {})
+    def merge_sections(incoming_sections)
+      merge(Configuration.new(sections: sections + incoming_sections))
+    end
+
+    def has_option?(key)
+      !!config[key.to_sym]
     end
 
     def ==(o)

data/lib/bookbinder/configuration_fetcher.rb

@@ -17,7 +17,7 @@ module Bookbinder
     end
 
     def fetch_credentials(environment = 'null-environment')
-      @credentials ||= credentials_provider.credentials("git@github.com:#{fetch_config.cred_repo}")
+      @credentials ||= credentials_provider.credentials(fetch_config.cred_repo_url)
       {
         aws: Config::AwsCredentials.new(
           @credentials.fetch('aws', {})
@@ -50,12 +50,10 @@ module Bookbinder
     def validate(config_hash)
       raise 'Your config.yml appears to be empty. Please check and try again.' unless config_hash
 
-      errors = configuration_validator.exceptions(config_hash,
-                                                  Configuration::CURRENT_SCHEMA_VERSION,
-                                                  Configuration::STARTING_SCHEMA_VERSION)
+      errors = configuration_validator.exceptions(config_hash)
       raise errors.first if errors.any?
 
-      Configuration.new(logger, config_hash)
+      Configuration.parse(config_hash)
     end
   end
 end

data/lib/bookbinder/configuration_validator.rb

@@ -1,6 +1,5 @@
 require_relative 'validation_checkers/duplicate_section_name_checker'
 require_relative 'validation_checkers/archive_menu_checker'
-require_relative 'validation_checkers/config_version_checker'
 require_relative 'validation_checkers/required_keys_checker'
 require_relative 'validation_checkers/repository_name_presence_checker'
 require_relative 'validation_checkers/dita_section_checker'
@@ -12,14 +11,8 @@ module Bookbinder
       @file_system_accessor = file_system_accessor
     end
 
-    def exceptions(config_hash, bookbinder_schema_version, starting_schema_version)
-      user_config_schema_version = config_hash['schema_version']
+    def exceptions(config_hash)
       exceptions = [
-        ConfigVersionChecker.new(Version.parse(bookbinder_schema_version),
-                                 Version.parse(starting_schema_version),
-                                 VersionCheckerMessages.new(Version.parse(user_config_schema_version),
-                                                         bookbinder_schema_version),
-                                 @logger),
         RequiredKeysChecker.new,
         DuplicateSectionNameChecker.new,
         RepositoryNamePresenceChecker.new,

data/lib/bookbinder/distributor.rb

@@ -11,7 +11,7 @@ module Bookbinder
     EXPIRATION_HOURS = 2
 
     def self.build(logger, options)
-      namespace = Ingest::DestinationDirectory.new(options[:book_repo], nil)
+      namespace = Ingest::DestinationDirectory.new(options[:book_repo])
       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)