bookbindery 1.0.0

data/lib/bookbinder/pdf_generator.rb

@@ -0,0 +1,73 @@
+require 'net/http'
+
+module Bookbinder
+  class PdfGenerator
+    class MissingSource < StandardError
+      def initialize(required_file)
+        super "Could not find file #{required_file}"
+      end
+    end
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def generate(sources, target, header, left_footer=nil)
+      sources.each { |s| check_destination_exists s }
+      check_destination_exists header
+
+      left_footer ||= "   © Copyright 2013-#{Time.now.year}, Pivotal"
+
+      toc_xslt_path = File.expand_path('../../../toc.xslt', __FILE__)
+
+      command = <<-CMD
+      wkhtmltopdf \
+      --disable-external-links \
+      --disable-javascript \
+      --load-error-handling ignore \
+      --margin-top 26mm \
+      --margin-bottom 13mm \
+      --header-spacing 10 \
+      --header-html #{header} \
+      --footer-spacing 5 \
+      --footer-font-size 10 \
+      --footer-left '#{left_footer}' \
+      --footer-center '[page] of [toPage]' \
+      --print-media-type \
+      toc --xsl-style-sheet #{toc_xslt_path} \
+      #{sources.join(' ')} \
+      #{target}
+      CMD
+
+      `#{command}`
+
+      raise "'wkhtmltopdf' appears to have failed" unless $?.success? && File.exist?(target)
+
+      @logger.log "\nYour PDF file was generated to #{target.green}"
+
+    end
+
+    def check_file_exists(required_file)
+      unless File.exist? required_file
+        @logger.error "\nPDF Generation failed (could not find file)!"
+        raise MissingSource, required_file
+      end
+    end
+
+    def check_destination_exists(url)
+      uri = URI(url)
+      if uri.class == URI::Generic
+        check_file_exists url
+      elsif uri.class == URI::HTTP
+        check_url_exists url
+      else
+        @logger.error "Malformed destination provided for PDF generation source: #{url}"
+      end
+    end
+
+    def check_url_exists(url)
+      res = Net::HTTP.get_response(URI(url))
+      raise MissingSource, url if res.code == '404'
+    end
+  end
+end

data/lib/bookbinder/publisher.rb

@@ -0,0 +1,125 @@
+require 'middleman-syntax'
+require_relative 'bookbinder_logger'
+require_relative 'directory_helpers'
+require_relative 'section'
+require_relative 'server_director'
+
+module Bookbinder
+  class Publisher
+    include DirectoryHelperMethods
+
+    def initialize(logger, spider, static_site_generator)
+      @gem_root = File.expand_path('../../../', __FILE__)
+      @logger = logger
+      @spider = spider
+      @static_site_generator = static_site_generator
+    end
+
+    def publish(cli_options, output_paths, publish_config, git_accessor)
+      intermediate_directory = output_paths.fetch(:output_dir)
+      final_app_dir = output_paths.fetch(:final_app_dir)
+      master_middleman_dir = output_paths.fetch(:master_middleman_dir)
+      master_dir = File.join intermediate_directory, 'master_middleman'
+      workspace_dir = File.join master_dir, 'source'
+      build_directory = File.join master_dir, 'build/.'
+      public_directory = File.join final_app_dir, 'public'
+
+      @versions = publish_config.fetch(:versions, [])
+      @book_repo = publish_config[:book_repo]
+      prepare_directories final_app_dir, intermediate_directory, workspace_dir, master_middleman_dir, master_dir, git_accessor
+      FileUtils.cp 'redirects.rb', final_app_dir if File.exists?('redirects.rb')
+
+      target_tag = cli_options[:target_tag]
+      sections = gather_sections(workspace_dir, publish_config, output_paths, target_tag, git_accessor)
+      book = Book.new(logger: @logger,
+                      full_name: @book_repo,
+                      sections: publish_config.fetch(:sections))
+      host_for_sitemap = publish_config.fetch(:host_for_sitemap)
+
+      generate_site(cli_options, output_paths, publish_config, master_dir, book, sections, build_directory, public_directory, git_accessor)
+      generate_sitemap(final_app_dir, host_for_sitemap, @spider)
+
+      @logger.log "Bookbinder bound your book into #{final_app_dir.to_s.green}"
+
+      !@spider.has_broken_links?
+    end
+
+    private
+
+    def generate_sitemap(final_app_dir, host_for_sitemap, spider)
+      server_director = ServerDirector.new(@logger, directory: final_app_dir)
+      raise "Your public host must be a single String." unless host_for_sitemap.is_a?(String)
+
+      server_director.use_server { |port| spider.generate_sitemap host_for_sitemap, port }
+    end
+
+    def generate_site(cli_options, output_paths, publish_config, middleman_dir, book, sections, build_dir, public_dir, git_accessor)
+      @static_site_generator.run(middleman_dir,
+                                 publish_config.fetch(:template_variables, {}),
+                                 output_paths[:local_repo_dir],
+                                 cli_options[:verbose],
+                                 book,
+                                 sections,
+                                 publish_config[:host_for_sitemap],
+                                 publish_config[:archive_menu],
+                                 git_accessor
+      )
+      FileUtils.cp_r build_dir, public_dir
+    end
+
+    def gather_sections(workspace, publish_config, output_paths, target_tag, git_accessor)
+      section_data = publish_config.fetch(:sections)
+      section_data.map do |attributes|
+        section = Section.get_instance(@logger,
+                                       section_hash: attributes,
+                                       destination_dir: workspace,
+                                       local_repo_dir: output_paths[:local_repo_dir],
+                                       target_tag: target_tag,
+                                       git_accessor: git_accessor)
+        section
+      end
+    end
+
+    def prepare_directories(final_app, middleman_scratch_space, middleman_source, master_middleman_dir, middleman_dir, git_accessor)
+      forget_sections(middleman_scratch_space)
+      FileUtils.rm_rf File.join final_app, '.'
+      FileUtils.mkdir_p middleman_scratch_space
+      FileUtils.mkdir_p File.join final_app, 'public'
+      FileUtils.mkdir_p middleman_source
+
+      copy_directory_from_gem 'template_app', final_app
+      copy_directory_from_gem 'master_middleman', middleman_dir
+      FileUtils.cp_r File.join(master_middleman_dir, '.'), middleman_dir
+
+      copy_version_master_middleman(middleman_source, git_accessor)
+    end
+
+    # Copy the index file from each version into the version's directory. Because version
+    # subdirectories are sections, this is the only way they get content from their master
+    # middleman directory.
+    def copy_version_master_middleman(dest_dir, git_accessor)
+      @versions.each do |version|
+        Dir.mktmpdir(version) do |tmpdir|
+          book = Book.from_remote(logger: @logger, full_name: @book_repo,
+                                  destination_dir: tmpdir, ref: version, git_accessor: git_accessor)
+          index_source_dir = File.join(tmpdir, book.directory, 'master_middleman', source_dir_name)
+          index_dest_dir = File.join(dest_dir, version)
+          FileUtils.mkdir_p(index_dest_dir)
+
+          Dir.glob(File.join(index_source_dir, 'index.*')) do |f|
+            FileUtils.cp(File.expand_path(f), index_dest_dir)
+          end
+        end
+      end
+    end
+
+    def forget_sections(middleman_scratch)
+      Section.store.clear
+      FileUtils.rm_rf File.join middleman_scratch, '.'
+    end
+
+    def copy_directory_from_gem(dir, output_dir)
+      FileUtils.cp_r File.join(@gem_root, "#{dir}/."), output_dir
+    end
+  end
+end

data/lib/bookbinder/pusher.rb

@@ -0,0 +1,34 @@
+require_relative 'app_fetcher'
+
+module Bookbinder
+  class Pusher
+    def initialize(cf_cli, app_fetcher)
+      @cf_cli = cf_cli
+      @app_fetcher = app_fetcher
+    end
+
+    def push(app_dir)
+      Dir.chdir(app_dir) do
+        cf_cli.login
+
+        old_app = app_fetcher.fetch_current_app
+
+        if old_app
+          new_app = old_app.with_flipped_name
+          cf_cli.start(new_app)
+          cf_cli.push(new_app)
+          cf_cli.map_routes(new_app)
+          cf_cli.takedown_old_target_app(old_app)
+        else
+          new_app = cf_cli.new_app
+          cf_cli.push(new_app)
+          cf_cli.map_routes(new_app)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :cf_cli, :app_fetcher
+  end
+end

data/lib/bookbinder/remote_yaml_credential_provider.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+require 'tempfile'
+
+module Bookbinder
+  class RemoteYamlCredentialProvider
+    def initialize(logger, repository, git_accessor = Git)
+      @logger = logger
+      @repository = repository
+      @git_accessor = git_accessor
+    end
+
+    def credentials
+      @logger.log "Processing #{@repository.full_name.cyan}"
+      Dir.mktmpdir do |destination_dir|
+        @repository.copy_from_remote(destination_dir, @git_accessor)
+        cred_file_yaml = File.join(destination_dir, @repository.short_name, 'credentials.yml')
+        YAML.load_file(cred_file_yaml)
+      end
+    end
+  end
+end

data/lib/bookbinder/section.rb

@@ -0,0 +1,78 @@
+require 'bookbinder/directory_helpers'
+
+module Bookbinder
+  class Section
+
+    def self.store
+      @@store ||= {}
+    end
+
+    def self.get_instance(logger,
+                          section_hash: {},
+                          local_repo_dir: nil,
+                          destination_dir: Dir.mktmpdir,
+                          target_tag: nil,
+                          git_accessor: Git)
+      @git_accessor = git_accessor
+      store.fetch([section_hash, local_repo_dir]) { acquire(logger, section_hash, local_repo_dir, destination_dir, target_tag, git_accessor) }
+    end
+
+    def initialize(logger, repository, subnav_template)
+      @logger = logger
+      @subnav_template = subnav_template
+      @repository = repository
+      @git_accessor = Git
+    end
+
+    def subnav_template
+      @subnav_template.gsub(/^_/, '').gsub(/\.erb$/, '') if @subnav_template
+    end
+
+    def directory
+      @repository.directory
+    end
+
+    def full_name
+      @repository.full_name
+    end
+
+    def copied?
+      @repository.copied?
+    end
+
+    def get_modification_date_for(file: nil, full_path: nil)
+      unless @repository.has_git_object?
+        begin
+          git_base_object = @git_accessor.open(@repository.path_to_local_repo)
+        rescue => e
+          raise "Invalid git repository! Cannot get modification date for section: #{@repository.path_to_local_repo}."
+        end
+      end
+      @repository.get_modification_date_for(file: file, git: git_base_object)
+    end
+
+    private
+
+    def self.acquire(logger, section_hash, local_repo_dir, destination, target_tag, git_accessor)
+      repository = section_hash['repository']
+      raise "section repository '#{repository}' is not a hash" unless repository.is_a?(Hash)
+      raise "section repository '#{repository}' missing name key" unless repository['name']
+      logger.log "Gathering #{repository['name'].cyan}"
+
+      repository = build_repository(logger, destination, local_repo_dir, section_hash, target_tag, git_accessor)
+      section = new(logger, repository, section_hash['subnav_template'])
+
+      store[[section_hash, local_repo_dir]] = section
+    end
+    private_class_method :acquire
+
+    def self.build_repository(logger, destination, local_repo_dir, repo_hash, target_tag, git_accessor)
+      if local_repo_dir
+        GitHubRepository.build_from_local(logger, repo_hash, local_repo_dir, destination)
+      else
+        GitHubRepository.build_from_remote(logger, repo_hash, destination, target_tag, git_accessor)
+      end
+    end
+    private_class_method :build_repository
+  end
+end

data/lib/bookbinder/server_director.rb

@@ -0,0 +1,53 @@
+require 'popen4'
+
+module Bookbinder
+  class ServerDirector
+    def initialize(logger, directory: nil, port: 41722)
+      @logger = logger
+      @directory = directory
+      @port = port
+    end
+
+    def use_server
+      Dir.chdir(@directory) do
+        POpen4::popen4("puma -p #{@port}") do |stdout, stderr, stdin, pid|
+          begin
+            wait_for_server(stdout)
+            consume_stream_in_separate_thread(stdout)
+            consume_stream_in_separate_thread(stderr)
+            yield @port
+          ensure
+            stop_server(pid)
+          end
+        end
+      end
+    end
+
+    private
+
+    def wait_for_server(io)
+      Kernel.sleep(1)
+      begin
+        line = io.gets
+        raise 'Puma could not start' if line.nil?
+
+        @logger.log "Vienna says, #{line}"
+      end until line.include?('Listening on')
+
+      @logger.log 'Vienna is lovely this time of year.'
+    end
+
+    def stop_server(pid)
+      Process.kill 'KILL', pid
+    end
+
+    # avoids deadlocks by ensuring rack doesn't hang waiting to write to stderr
+    def consume_stream_in_separate_thread(stream)
+      Thread.new do
+        s = nil
+        while stream.read(1024, s)
+        end
+      end
+    end
+  end
+end

data/lib/bookbinder/shell_out.rb

@@ -0,0 +1,19 @@
+require 'open3'
+
+module Bookbinder
+  module ShellOut
+    def shell_out(command, failure_okay = false)
+      Open3.popen3(command) do |input, stdout, stderr, wait_thr|
+        command_failed = (wait_thr.value != 0)
+        announce_failure(failure_okay, stderr, stdout) if command_failed
+        stdout.read
+      end
+    end
+
+    def announce_failure(failure_okay, stderr, stdout)
+      contents_of_stderr = stderr.read
+      error_message = contents_of_stderr.empty? ? stdout.read : contents_of_stderr
+      raise "\n#{error_message}" unless failure_okay
+    end
+  end
+end

data/lib/bookbinder/sieve.rb

@@ -0,0 +1,62 @@
+module Bookbinder
+  class Sieve
+    def initialize(domain: ->(){ raise 'You must supply a domain parameter.' }.call)
+      @unverified_fragments_by_url = {}
+      @domain = domain
+    end
+
+    def links_from(page, is_first_pass)
+      if page.not_found?
+        working = []
+        broken  = [Spider.prepend_location(page.referer, page.url)]
+      else
+        working = [page.url.to_s]
+        broken  = broken_fragments_targeting(page, is_first_pass)
+        store_unverified_fragments_from(page) if is_first_pass
+      end
+
+      return broken, working
+    end
+
+    private
+
+    def store_unverified_fragments_from(page)
+      @unverified_fragments_by_url.merge! fragments_targeting_other_pages_from page
+    end
+
+    def broken_fragments_targeting(page, first_pass)
+      first_pass ? local_fragments_missing_from(page) : remote_fragments_missing_from(page)
+    end
+
+    def local_fragments_missing_from(page)
+      local_fragments = page.fragment_identifiers targeting_locally: true
+      local_fragments.reject { |uri| page.has_target_for?(uri) }.map { |uri| Spider.prepend_location(page.url, uri) }
+    end
+
+    def remote_fragments_missing_from(page)
+      @unverified_fragments_by_url.fetch(page.url, []).reject { |localized_identifier| page.has_target_for? URI(strip_location(localized_identifier)) }
+    end
+
+    def fragments_targeting_other_pages_from(page)
+      uris_with_fragments = page.fragment_identifiers(targeting_locally: false)
+      uris_with_fragments.reduce({}) { |dict, uri| merge_uris_under_targets(dict, page, uri) }
+    end
+
+    def merge_uris_under_targets(dict, page, uri)
+      target_url = URI::join @domain, uri.path
+      localized_identifier = Spider.prepend_location(page.url, "##{uri.fragment}")
+
+      if dict.has_key? target_url
+        dict[target_url] << localized_identifier
+      else
+        dict[target_url] = [localized_identifier]
+      end
+
+      dict
+    end
+
+    def strip_location(id)
+      id.split('=> ').last
+    end
+  end
+end