bookbindery 1.0.0

data/lib/bookbinder/commands/push_local_to_staging.rb

@@ -0,0 +1,35 @@
+require_relative '../distributor'
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class PushLocalToStaging < BookbinderCommand
+      extend Commands::Naming
+
+      def self.usage
+        "push_local_to_staging \t \t  \t Push the contents of final_app to the staging host specified in credentials.yml"
+      end
+
+      def run(_)
+        Distributor.build(@logger, options).distribute
+        0
+      end
+
+      private
+
+      def options
+        {
+            app_dir: './final_app',
+            build_number: ENV['BUILD_NUMBER'],
+
+            aws_credentials: config.aws_credentials,
+            cf_credentials: config.cf_staging_credentials,
+
+            book_repo: config.book_repo,
+            production: false
+        }
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/push_to_prod.rb

@@ -0,0 +1,35 @@
+require_relative '../distributor'
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class PushToProd < BookbinderCommand
+      extend Commands::Naming
+
+      def self.usage
+        "push_to_prod [build_#] \t \t \t Push latest or <build_#> from your S3 bucket to the production host specified in credentials.yml"
+      end
+
+      def run(arguments)
+        Distributor.build(@logger, options(arguments)).distribute
+        0
+      end
+
+      private
+
+      def options(arguments)
+        {
+          app_dir: Dir.mktmpdir,
+          build_number: arguments[0],
+
+          aws_credentials: config.aws_credentials,
+          cf_credentials: config.cf_production_credentials,
+
+          book_repo: config.book_repo,
+          production: true
+        }
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/run_publish_ci.rb

@@ -0,0 +1,42 @@
+require_relative 'bookbinder_command'
+require_relative 'naming'
+require_relative 'publish'
+require_relative 'push_local_to_staging'
+require_relative 'build_and_push_tarball'
+
+module Bookbinder
+  module Commands
+    class RunPublishCI < BookbinderCommand
+      extend Commands::Naming
+
+      def self.usage
+        "run_publish_ci \t \t \t \t Run publish, push_local_to_staging, and build_and_push_tarball for CI purposes"
+      end
+
+      def run(cli_args)
+        check_params
+        all_successfully_ran = publish(cli_args) == 0 && push_to_staging == 0 && push_tarball == 0
+        all_successfully_ran ? 0 : 1
+      end
+
+      private
+
+      def check_params
+        raise BuildAndPushTarball::MissingBuildNumber unless ENV['BUILD_NUMBER']
+        config.book_repo
+      end
+
+      def publish(cli_args)
+        Publish.new(@logger, @configuration_fetcher).run(['github'] + cli_args)
+      end
+
+      def push_to_staging
+        PushLocalToStaging.new(@logger, @configuration_fetcher).run []
+      end
+
+      def push_tarball
+        BuildAndPushTarball.new(@logger, @configuration_fetcher).run []
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/tag.rb

@@ -0,0 +1,31 @@
+require_relative '../book'
+require_relative '../bookbinder_logger'
+require_relative '../cli_error'
+
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class Tag < BookbinderCommand
+      extend Commands::Naming
+
+      def self.usage
+        "tag <git tag> \t \t \t \t Apply the specified <git tag> to your book and all sections of your book"
+      end
+
+      def run(params)
+        tag = params.first
+        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
+
+        @logger.log 'Success!'.green
+        @logger.log " #{book.full_name.yellow} and its sections were tagged with #{tag.blue}"
+        0
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/update_local_doc_repos.rb

@@ -0,0 +1,27 @@
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class UpdateLocalDocRepos < BookbinderCommand
+      extend Commands::Naming
+
+      def self.usage
+        "update_local_doc_repos \t \t \t 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)
+        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)
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/version.rb

@@ -0,0 +1,25 @@
+require_relative 'bookbinder_command'
+
+module Bookbinder
+  module Commands
+    class Version < BookbinderCommand
+      def self.to_s
+        'version'
+      end
+
+      def self.command_name
+        '--version'
+      end
+
+      def self.usage
+        "--version \t \t \t \t Print the version of bookbinder"
+      end
+
+      def run(*)
+        @logger.log "bookbinder #{Gem::Specification::load(File.join GEM_ROOT, "bookbinder.gemspec").version}"
+        0
+      end
+
+    end
+  end
+end

data/lib/bookbinder/configuration.rb

@@ -0,0 +1,163 @@
+require_relative 'remote_yaml_credential_provider'
+require_relative 'git_hub_repository'
+
+module Bookbinder
+  class Configuration
+
+    CURRENT_SCHEMA_VERSION = '1.0.0'
+    STARTING_SCHEMA_VERSION = '1.0.0'
+
+    class CredentialKeyError < StandardError;
+    end
+
+    class ConfigSchemaUnsupportedError < StandardError;
+    end
+
+    class AwsCredentials
+      REQUIRED_KEYS = %w(access_key secret_key green_builds_bucket).freeze
+
+      def initialize(cred_hash)
+        @creds = cred_hash
+      end
+
+      REQUIRED_KEYS.each do |method_name|
+        define_method(method_name) do
+          begin
+            creds.fetch(method_name)
+          rescue KeyError => e
+            raise CredentialKeyError, e
+          end
+        end
+      end
+
+      private
+
+      attr_reader :creds
+    end
+
+    class CfCredentials
+      REQUIRED_KEYS = %w(api_endpoint organization app_name).freeze
+      OPTIONAL_KEYS = %w(username password production_space production_host staging_space staging_host).freeze
+
+      def initialize(cred_hash, is_production)
+        @creds = cred_hash
+        @is_production = is_production
+      end
+
+      REQUIRED_KEYS.each do |method_name|
+        define_method(method_name) do
+          fetch(method_name)
+        end
+      end
+
+      OPTIONAL_KEYS.each do |method_name|
+        define_method(method_name) do
+          creds.fetch(method_name, nil)
+        end
+      end
+
+      def routes
+        key = is_production ? 'production_host' : 'staging_host'
+        fetch(key) if correctly_formatted_domain_and_routes?(key)
+      end
+
+      def flat_routes
+        routes.reduce([]) do |all_routes, domain_apps|
+          domain, apps = domain_apps
+          all_routes + apps.map { |app| [domain, app] }
+        end
+      end
+
+      def space
+        key = is_production ? 'production_space' : 'staging_space'
+        fetch(key)
+      end
+
+      private
+
+      attr_reader :creds, :is_production
+
+      def fetch(key)
+        creds.fetch(key)
+      rescue KeyError => e
+        raise CredentialKeyError, e
+      end
+
+      def correctly_formatted_domain_and_routes?(deploy_environment)
+        routes_hash = fetch(deploy_environment)
+        domains = routes_hash.keys
+        domains.each { |domain| correctly_formatted_domain?(domain, routes_hash) }
+      end
+
+      def correctly_formatted_domain?(domain, routes_hash)
+        raise 'Each domain in credentials must be a single string.' unless domain.is_a? String
+        raise "Domain #{domain} in credentials must contain a web extension, e.g. '.com'." unless domain.include?('.')
+        raise "Did you mean to add a list of hosts for domain #{domain}? Check your credentials.yml." unless routes_hash[domain]
+        raise "Hosts in credentials must be nested as an array under the desired domain #{domain}." unless routes_hash[domain].is_a? Array
+        raise "Did you mean to provide a hostname for the domain #{domain}? Check your credentials.yml." if routes_hash[domain].any?(&:nil?)
+      end
+    end
+
+    attr_reader :schema_version, :schema_major_version, :schema_minor_version, :schema_patch_version
+
+    def initialize(logger, config_hash)
+      @logger = logger
+      @config = config_hash
+    end
+
+    CONFIG_REQUIRED_KEYS = %w(book_repo layout_repo cred_repo sections public_host pdf pdf_index versions)
+    CONFIG_OPTIONAL_KEYS = %w(archive_menu)
+
+    CONFIG_REQUIRED_KEYS.each do |method_name|
+      define_method(method_name) do
+        config.fetch(method_name)
+      end
+    end
+
+    CONFIG_OPTIONAL_KEYS.each do |method_name|
+      define_method(method_name) do
+        config[method_name]
+      end
+    end
+
+    def has_option?(key)
+      @config.has_key?(key)
+    end
+
+    def template_variables
+      config.fetch('template_variables', {})
+    end
+
+    def aws_credentials
+      @aws_creds ||= AwsCredentials.new(credentials.fetch('aws'))
+    end
+
+    def cf_staging_credentials
+      @cf_staging_creds ||= CfCredentials.new(credentials.fetch('cloud_foundry'), false)
+    end
+
+    def cf_production_credentials
+      @cf_prod_creds ||= CfCredentials.new(credentials.fetch('cloud_foundry'), true)
+    end
+
+    def ==(o)
+      (o.class == self.class) && (o.config == self.config)
+    end
+
+    alias_method :eql?, :==
+
+    protected
+
+    attr_reader :config
+
+    private
+
+    def credentials
+      @credentials ||= RemoteYamlCredentialProvider.new(@logger, credentials_repository).credentials
+    end
+
+    def credentials_repository
+      @credentials_repository ||= GitHubRepository.new(logger: @logger, full_name: cred_repo)
+    end
+  end
+end

data/lib/bookbinder/configuration_fetcher.rb

@@ -0,0 +1,55 @@
+require_relative 'yaml_loader'
+
+module Bookbinder
+
+  class ConfigurationFetcher
+    attr_reader   :logger,
+                  :configuration_validator,
+                  :config,
+                  :config_file_path
+
+    def initialize(logger, configuration_validator, loader)
+      @loader = loader
+      @logger = logger
+      @configuration_validator = configuration_validator
+    end
+
+    def fetch_config
+      @config ||= validate(read_config_file)
+    end
+
+    def set_config_file_path config_file_path
+      @config_file_path = config_file_path
+    end
+
+
+    private
+
+    attr_reader :loader
+
+    def read_config_file
+
+      begin
+        config_hash = loader.load(config_file_path)
+      rescue FileNotFoundError => e
+        raise "The configuration file specified does not exist. Please create a config #{e} file at #{config_file_path} and try again."
+      rescue InvalidSyntaxError => e
+        raise "There is a syntax error in your config file: \n #{e}"
+      end
+
+      if config_hash
+        if File.exists?('./pdf_index.yml')
+          config_hash['pdf_index'] = loader.load(config_file_path)
+        else
+          config_hash['pdf_index'] = nil
+        end
+      end
+
+      config_hash
+    end
+
+    def validate(config_hash)
+      Configuration.new(logger, config_hash) if configuration_validator.valid?(config_hash, Configuration::CURRENT_SCHEMA_VERSION, Configuration::STARTING_SCHEMA_VERSION)
+    end
+  end
+end

data/lib/bookbinder/configuration_validator.rb

@@ -0,0 +1,162 @@
+module Bookbinder
+
+  class DuplicateSectionNameChecker
+    def check(config)
+      if duplicate_section_names?(config)
+        ConfigurationValidator::DuplicateSectionNameError
+      end
+    end
+
+    private
+
+    def duplicate_section_names?(config)
+      directory_names = config['sections'].map {|section| section['directory']}
+      directory_names.length != directory_names.uniq.length
+    end
+
+  end
+
+  class ArchiveMenuChecker
+    def initialize(file_system_accessor)
+      @file_system_accessor = file_system_accessor
+    end
+
+    def check(config)
+      partial_location = './master_middleman/source/archive_menus/_default.erb'
+      if config.has_key?("archive_menu") && config["archive_menu"].nil?
+        ConfigurationValidator::ArchiveMenuNotDefinedError.new 'Did you mean to provide an archive menu value to display? If you use the archive_menu key, you must provide at least one value.'
+      elsif archive_items(config).include?(nil)
+        ConfigurationValidator::EmptyArchiveItemsError.new 'Did you forget to add a value to the archive_menu?'
+      elsif config.has_key?("archive_menu") && !@file_system_accessor.file_exist?(partial_location)
+        ConfigurationValidator::MissingArchiveMenuPartialError.new "You must provide a template partial named at #{partial_location}"
+      end
+    end
+
+    private
+
+    def archive_items(config)
+      config.fetch('archive_menu', [])
+    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
+
+  class ConfigVersionChecker
+    def initialize(bookbinder_schema_version, starting_schema_version, messages, logger)
+      @bookbinder_schema_version = bookbinder_schema_version
+      @starting_schema_version = starting_schema_version
+      @messages = messages
+      @logger = logger
+    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
+          @logger.warn nonbreaking_schema_message_for("minor")
+        elsif user_schema_version.patch < bookbinder_schema_version.patch
+          @logger.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
+
+    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
+
+  class ConfigurationValidator
+    DuplicateSectionNameError = Class.new(RuntimeError)
+    MissingArchiveMenuPartialError = Class.new(RuntimeError)
+    EmptyArchiveItemsError = Class.new(RuntimeError)
+    ArchiveMenuNotDefinedError = Class.new(RuntimeError)
+
+    def initialize(logger, file_system_accessor)
+      @logger = logger
+      @file_system_accessor = file_system_accessor
+    end
+
+    def valid?(config_hash, bookbinder_schema_version, starting_schema_version)
+      raise 'Your config.yml appears to be empty. Please check and try again.' unless config_hash
+
+      user_config_schema_version = config_hash['schema_version']
+      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),
+        DuplicateSectionNameChecker.new,
+        ArchiveMenuChecker.new(@file_system_accessor)
+      ].map do |checker|
+        checker.check(config_hash)
+      end
+      exception = exceptions.compact.first
+      raise exception if exception
+
+      true
+    end
+  end
+end