bookbindery 1.0.0

data/lib/bookbinder/cf_routes.rb

@@ -0,0 +1,19 @@
+module Bookbinder
+  class CfRoutes
+    def initialize(raw_routes)
+      @raw_routes = raw_routes
+    end
+
+    def apps_by_host_and_domain
+      @apps_by_host_and_domain ||= Hash[
+          raw_routes.lines[3..-1].
+              map { |line| line.split(/\s+/, 3) }.
+              map { |item| [item[0..1], item[2].split(',').map(&:strip)] }
+      ]
+    end
+
+    private
+
+    attr_reader :raw_routes
+  end
+end

data/lib/bookbinder/cli.rb

@@ -0,0 +1,68 @@
+require_relative 'command_runner'
+require_relative 'local_file_system_accessor'
+require_relative 'command_validator'
+
+require_relative 'commands/build_and_push_tarball'
+require_relative 'commands/generate_pdf'
+require_relative 'commands/publish'
+require_relative 'commands/version'
+require_relative 'commands/help'
+
+module Bookbinder
+  class Cli
+    FLAGS = [
+      Commands::Version,
+      Commands::Help
+    ]
+
+    COMMANDS = [
+      Commands::BuildAndPushTarball,
+      Commands::GeneratePDF,
+      Commands::Publish,
+      Commands::PushLocalToStaging,
+      Commands::PushToProd,
+      Commands::RunPublishCI,
+      Commands::Tag,
+      Commands::UpdateLocalDocRepos,
+    ].freeze
+
+    def run(args)
+      command_name = args[0]
+      command_arguments = args[1..-1]
+
+      logger = BookbinderLogger.new
+      yaml_loader = YAMLLoader.new
+      local_file_system_accessor = LocalFileSystemAccessor.new
+      configuration_validator = ConfigurationValidator.new(logger, local_file_system_accessor)
+      configuration_fetcher = ConfigurationFetcher.new(logger, configuration_validator, yaml_loader)
+      configuration_fetcher.set_config_file_path './config.yml'
+      usage_messenger = UsageMessenger.new
+      usage_message = usage_messenger.construct_for(COMMANDS, FLAGS)
+      command_validator = CommandValidator.new usage_messenger, COMMANDS + FLAGS, usage_message
+
+      command_runner = CommandRunner.new(configuration_fetcher, usage_message, logger, COMMANDS + FLAGS)
+
+      begin
+        command_name ? command_validator.validate!(command_name) : command_name = '--help'
+
+        command_runner.run command_name, command_arguments
+
+      rescue Commands::Publish::VersionUnsupportedError => e
+        logger.error "config.yml at version '#{e.message}' has an unsupported API."
+        1
+      rescue Configuration::CredentialKeyError => e
+        logger.error "#{e.message}, in credentials.yml"
+        1
+      rescue KeyError => e
+        logger.error "#{e.message} from your configuration."
+        1
+      rescue CliError::UnknownCommand => e
+        logger.log e.message
+        1
+      rescue RuntimeError => e
+        logger.error e.message
+        1
+      end
+    end
+  end
+end

data/lib/bookbinder/cli_error.rb

@@ -0,0 +1,6 @@
+module Bookbinder
+  module CliError
+    InvalidArguments = Class.new(StandardError)
+    UnknownCommand = Class.new(StandardError)
+  end
+end

data/lib/bookbinder/code_example.rb

@@ -0,0 +1,40 @@
+require_relative 'section'
+
+module Bookbinder
+  class CodeExample < Section
+    class InvalidSnippet < StandardError
+      def initialize(repo, marker)
+        super "Error with marker #{marker.cyan} #{'in'.red} #{repo.cyan}#{'.'.red}"
+      end
+    end
+
+    def get_snippet_and_language_at(marker)
+      unless @repository.copied?
+        @repository.announce_skip
+        return ''
+      end
+
+      prepared_snippet_at(marker)
+    end
+
+    private
+
+    def prepared_snippet_at(marker)
+      snippet = ''
+      FileUtils.cd(@repository.copied_to) { snippet = scrape_for(marker) }
+
+      raise InvalidSnippet.new(full_name, marker) if snippet.empty?
+      lines = snippet.split("\n")
+      language_match = lines[0].match(/code_snippet #{Regexp.escape(marker)} start (\w+)/)
+      language = language_match[1] if language_match
+      [lines[1..-2].join("\n"), language]
+    end
+
+    def scrape_for(marker)
+      locale = 'LC_CTYPE=C LANG=C' # Quiets 'sed: RE error: illegal byte sequence'
+      result = `#{locale} find . -exec sed -ne '/code_snippet #{marker} start/,/code_snippet #{marker} end/ p' {} \\; 2> /dev/null`
+      result = "" unless result.lines.last && result.lines.last.match(/code_snippet #{marker} end/)
+      result
+    end
+  end
+end

data/lib/bookbinder/command_runner.rb

@@ -0,0 +1,32 @@
+require_relative 'cli_error'
+
+module Bookbinder
+  class CommandRunner
+    def initialize(configuration_fetcher, usage_message, logger, commands)
+      @configuration_fetcher = configuration_fetcher
+      @usage_message = usage_message
+      @logger = logger
+      @commands = commands
+    end
+
+    def run(command_name, command_arguments)
+      command = commands.detect { |known_command| known_command.command_name == command_name }
+      begin
+        if command_name == '--help'
+          command.new(logger, usage_message).run command_arguments
+        else
+          command.new(logger, @configuration_fetcher).run command_arguments
+        end
+      rescue CliError::InvalidArguments
+        logger.log command.usage
+        1
+      end
+    end
+
+    private
+
+    attr_reader :logger, :usage_message, :commands
+
+  end
+end
+

data/lib/bookbinder/command_validator.rb

@@ -0,0 +1,24 @@
+require_relative 'cli_error'
+
+module Bookbinder
+  class CommandValidator
+    def initialize(usage_messenger, commands, usage_text)
+      @usage_messenger = usage_messenger
+      @commands = commands
+      @usage_text = usage_text
+    end
+
+    def validate! command_name
+      known_command_names = commands.map(&:command_name)
+      command_type = "#{command_name}".match(/^--/) ? 'flag' : 'command'
+      if !known_command_names.include?(command_name)
+        raise CliError::UnknownCommand.new "Unrecognized #{command_type} '#{command_name}'\n" + usage_text
+      end
+    end
+
+    private
+
+    attr_reader :usage_messenger, :commands, :usage_text
+  end
+end
+

data/lib/bookbinder/commands/bookbinder_command.rb

@@ -0,0 +1,18 @@
+module Bookbinder
+  module Commands
+    class BookbinderCommand
+      def initialize(logger, configuration_fetcher)
+        @logger = logger
+        @configuration_fetcher = configuration_fetcher
+      end
+
+      private
+
+      def config
+        @config ||= configuration_fetcher.fetch_config
+      end
+
+      attr_reader :configuration_fetcher
+    end
+  end
+end

data/lib/bookbinder/commands/build_and_push_tarball.rb

@@ -0,0 +1,31 @@
+require_relative 'naming'
+require_relative 'bookbinder_command'
+require_relative '../archive'
+
+module Bookbinder
+  module Commands
+    class BuildAndPushTarball < BookbinderCommand
+      extend Commands::Naming
+
+      class MissingBuildNumber < StandardError
+        def initialize
+          super 'You must set $BUILD_NUMBER to push an identifiable build.'
+        end
+      end
+
+      def self.usage
+        "build_and_push_tarball \t  \t  \t Create a tarball from the final_app directory and push to the S3 bucket specified in your credentials.yml"
+      end
+
+      def run(_)
+        raise MissingBuildNumber unless ENV['BUILD_NUMBER']
+        config = configuration_fetcher.fetch_config
+        aws_credentials = config.aws_credentials
+        repository = Archive.new(logger: @logger, key: aws_credentials.access_key, secret: aws_credentials.secret_key)
+        repository.create_and_upload_tarball(build_number: ENV['BUILD_NUMBER'], bucket: aws_credentials.green_builds_bucket,
+                                             namespace: GitHubRepository.new(logger: @logger, full_name: config.book_repo).short_name)
+        0
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/generate_pdf.rb

@@ -0,0 +1,140 @@
+require_relative '../pdf_generator'
+require_relative '../server_director'
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class GeneratePDF < BookbinderCommand
+      extend Commands::Naming
+
+      class AppNotPublished < StandardError
+        def initialize(msg='You must publish locally before you generate a PDF.')
+          super(msg)
+        end
+      end
+
+      class PDFConfigMissing < StandardError
+        def initialize(file)
+          super("PDF config file '#{file}' does not exist.")
+        end
+      end
+
+      class PDFOptionMissing < StandardError
+        def initialize(msg='No PDF options provided in config.yml')
+          super(msg)
+        end
+      end
+
+      class IncompletePDFConfig < StandardError
+        def initialize(file:nil, key:nil)
+          super("#{file} is missing required key '#{key}'")
+        end
+      end
+
+      def self.usage
+        "generate_pdf [<file_name>.yml] \t \t Generate a PDF from the files specified in <file_name.yml>"
+      end
+
+      def run(params)
+        raise AppNotPublished unless Dir.exists?('final_app')
+
+        @pdf_config_file = find_pdf_config_file(params)
+
+        ServerDirector.new(@logger, directory: 'final_app').use_server { |port| capture_pages_into_pdf_at(port) }
+        0
+      end
+
+      def find_pdf_config_file(params)
+        if params.first
+          pdf_config_file = File.expand_path(params.first)
+          raise PDFConfigMissing, File.basename(pdf_config_file) unless File.exists?(pdf_config_file)
+          pdf_config_file
+        else
+          @logger.warn "Declaring PDF options in config.yml is deprecated.\nDeclare them in a PDF config file, instead, and target that file when you re-invoke bookbinder.\ne.g. bookbinder generate_pdf theGoodParts.yml"
+        end
+      end
+
+      private
+
+      def capture_pages_into_pdf_at(port)
+        local_host = "localhost:#{port}"
+        header = pdf_options.fetch('header') { raise IncompletePDFConfig, {file: @pdf_config_file, key: :header} }
+
+        output_filename = get_output_file_name
+        urls_to_capture = get_urls_to_capture(local_host)
+
+        PdfGenerator.new(@logger).generate(urls_to_capture, output_filename, "http://#{local_host}/#{header}", pdf_options['copyright_notice'])
+      end
+
+      def pdf_options
+        @pdf_options ||= @pdf_config_file ? YAML.load(File.read(@pdf_config_file)) : main_config_pdf_options
+      end
+
+      def main_config_pdf_options
+        raise PDFOptionMissing unless config.has_option?('pdf')
+        {
+            'filename' => config.pdf.fetch('filename'),
+            'header' => config.pdf.fetch('header')
+        }
+      end
+
+      def get_output_file_name
+        if @pdf_config_file
+          File.basename(@pdf_config_file).gsub(/yml/, 'pdf')
+        else
+          pdf_options.fetch('filename')
+        end
+      end
+
+      def get_urls_to_capture(local_host)
+        if @pdf_config_file
+          pages = pdf_options.fetch('pages')
+          return expand_urls(pages, local_host) if any_include_wildcard?(pages)
+          pages.map { |l| "http://#{local_host}/#{l}" }
+        else
+          sitemap_links(local_host)
+        end
+      end
+
+      def any_include_wildcard?(pages)
+        pages.each do |page|
+          return true if page.include?('*')
+        end
+        false
+      end
+
+      def expand_urls(pages, local_host)
+        final_pages = []
+        pages.each do |page|
+          if page.include?('*')
+            matching_pages = find_matching_files_in_directory(page, local_host)
+            final_pages += matching_pages
+          else
+            final_pages << "http://#{local_host}/#{page}"
+          end
+        end
+        final_pages
+      end
+
+      def find_matching_files_in_directory(wildcard_page, local_host)
+        wildcard_path = wildcard_page.gsub('*','')
+        possible_links = sitemap_links(local_host)
+        possible_links.select { |link| URI(link).path.match(/^\/#{Regexp.escape(wildcard_path)}/)}
+      end
+
+      def sitemap_links(local_host)
+        raw_links = Nokogiri::XML(sitemap).css('loc').map &:inner_html
+        deployed_host = URI(raw_links[0]).host
+
+        deployed_host ?
+            raw_links.map { |l| l.gsub(/#{Regexp.escape(deployed_host)}/, local_host) } :
+            raw_links.map { |l| "http://#{local_host}/#{l}" }
+      end
+
+      def sitemap
+        File.read File.join('public', 'sitemap.xml')
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/help.rb

@@ -0,0 +1,31 @@
+module Bookbinder
+  module Commands
+    class Help
+      def initialize(logger, usage_message)
+        @logger = logger
+        @usage_message = usage_message
+      end
+
+      def self.to_s
+        'help'
+      end
+
+      def self.command_name
+        '--help'
+      end
+
+      def self.usage
+        "--help \t \t \t \t \t Print this message"
+      end
+
+      def run(*)
+        logger.log(usage_message)
+        0
+      end
+
+      private
+
+      attr_reader :logger, :usage_message
+    end
+  end
+end

data/lib/bookbinder/commands/naming.rb

@@ -0,0 +1,9 @@
+module Bookbinder
+  module Commands
+    module Naming
+      def command_name
+        name.demodulize.underscore
+      end
+    end
+  end
+end

data/lib/bookbinder/commands/publish.rb

@@ -0,0 +1,138 @@
+require_relative '../book'
+require_relative '../cli_error'
+require_relative '../configuration'
+require_relative '../directory_helpers'
+require_relative '../middleman_runner'
+require_relative '../publisher'
+require_relative '../spider'
+require_relative 'bookbinder_command'
+require_relative 'naming'
+
+module Bookbinder
+  module Commands
+    class Publish < BookbinderCommand
+      VersionUnsupportedError = Class.new(StandardError)
+
+      include Bookbinder::DirectoryHelperMethods
+      extend Commands::Naming
+
+      def self.usage
+        "publish <local|github> [--verbose] \t Bind the sections specified in config.yml from <local> or <github> into the final_app directory"
+      end
+
+      def run(cli_arguments, git_accessor=Git)
+        raise CliError::InvalidArguments unless arguments_are_valid?(cli_arguments)
+        @git_accessor = git_accessor
+
+        final_app_dir = File.absolute_path('final_app')
+        bind_book(cli_arguments, final_app_dir)
+      end
+
+      private
+
+      def bind_book(cli_arguments, final_app_dir)
+        generate_site_etc(cli_arguments, final_app_dir)
+      end
+
+      def generate_site_etc(cli_args, final_app_dir, target_tag=nil)
+        # TODO: general solution to turn all string keys to symbols
+        verbosity = cli_args.include?('--verbose')
+        location = cli_args[0]
+
+        cli_options = { verbose: verbosity, target_tag: target_tag }
+        output_paths = output_directory_paths(location, final_app_dir)
+        publish_config = publish_config(location)
+        spider = Spider.new(@logger, app_dir: final_app_dir)
+        static_site_generator = MiddlemanRunner.new(@logger)
+
+        success = Publisher.new(@logger, spider, static_site_generator).publish(cli_options, output_paths, publish_config, @git_accessor)
+        success ? 0 : 1
+      end
+
+      def output_directory_paths(location, final_app_dir)
+        local_repo_dir = (location == 'local') ? File.absolute_path('..') : nil
+
+        {
+          final_app_dir: final_app_dir,
+          local_repo_dir: local_repo_dir,
+          output_dir: File.absolute_path(output_dir_name),
+          master_middleman_dir: layout_repo_path(local_repo_dir)
+        }
+      end
+
+      def publish_config(location)
+        arguments = {
+            sections: config.sections,
+            book_repo: config.book_repo,
+            host_for_sitemap: config.public_host,
+            archive_menu: config.archive_menu
+        }
+
+        optional_arguments = {}
+        optional_arguments.merge!(template_variables: config.template_variables) if config.respond_to?(:template_variables)
+        if publishing_to_github? location
+          config.versions.each { |version| arguments[:sections].concat sections_from version, @git_accessor }
+          optional_arguments.merge!(versions: config.versions)
+        end
+
+        arguments.merge! optional_arguments
+      end
+
+      def sections_from(version, git_accessor)
+        config_file = File.join book_checkout(version, git_accessor), 'config.yml'
+        attrs       = YAML.load(File.read(config_file))['sections']
+        raise VersionUnsupportedError.new(version) if attrs.nil?
+
+        attrs.map do |section_hash|
+          section_hash['repository']['ref'] = version
+          section_hash['directory'] = File.join(version, section_hash['directory'])
+          section_hash
+        end
+      end
+
+      def book_checkout(ref, git_accessor=Git)
+        temp_workspace = Dir.mktmpdir('book_checkout')
+        book = Book.from_remote(logger: @logger,
+                                full_name: config.book_repo,
+                                destination_dir: temp_workspace,
+                                ref: ref,
+                                git_accessor: git_accessor,
+                               )
+
+        File.join temp_workspace, book.directory
+      end
+
+      def layout_repo_path(local_repo_dir)
+        if config.has_option?('layout_repo')
+          if local_repo_dir
+            File.join(local_repo_dir, config.layout_repo.split('/').last)
+          else
+            section = {'repository' => {'name' => config.layout_repo}}
+            destination_dir = Dir.mktmpdir
+            repository =  GitHubRepository.build_from_remote(@logger, section, destination_dir, 'master', @git_accessor)
+            if repository
+              File.join(destination_dir, repository.directory)
+            else
+              raise 'failed to fetch repository'
+            end
+          end
+        else
+          File.absolute_path('master_middleman')
+        end
+      end
+
+      def arguments_are_valid?(arguments)
+        return false unless arguments.any?
+        verbose           = arguments[1] && arguments[1..-1].include?('--verbose')
+        tag_provided      = arguments[1] && (arguments[1..-1] - ['--verbose']).any?
+        nothing_special   = arguments[1..-1].empty?
+
+        %w(local github).include?(arguments[0]) && (tag_provided || verbose || nothing_special)
+      end
+
+      def publishing_to_github?(publish_location)
+        config.has_option?('versions') && publish_location != 'local'
+      end
+    end
+  end
+end