bookbindery 2.1.5 → 3.0.1

data/lib/bookbinder/commands/generate_pdf.rb

@@ -1,141 +0,0 @@
-require_relative '../pdf_generator'
-require_relative '../server_director'
-require_relative 'bookbinder_command'
-require_relative 'naming'
-
-module Bookbinder
-  module Commands
-    class GeneratePDF < BookbinderCommand
-      include 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 usage
-        ["generate_pdf [<file_name>.yml]",
-         "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/pdf_generator.rb

@@ -1,73 +0,0 @@
-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 \
-      --enable-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

@@ -1,58 +0,0 @@
-require 'middleman-syntax'
-require_relative 'deprecated_logger'
-require_relative 'directory_helpers'
-require_relative 'repositories/section_repository'
-
-module Bookbinder
-  class Publisher
-    include DirectoryHelperMethods
-
-    def initialize(logger, sitemap_writer, static_site_generator, file_system_accessor)
-      @logger = logger
-      @sitemap_writer = sitemap_writer
-      @static_site_generator = static_site_generator
-      @file_system_accessor = file_system_accessor
-    end
-
-    def publish(subnavs, cli_options, output_paths, publish_config)
-      intermediate_directory = output_paths.output_dir
-      final_app_dir = output_paths.final_app_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'
-
-      FileUtils.cp 'redirects.rb', final_app_dir if File.exists?('redirects.rb')
-
-      host_for_sitemap = publish_config.fetch(:host_for_sitemap)
-
-      generate_site(cli_options, output_paths, publish_config, master_dir, workspace_dir, subnavs, build_directory, public_directory)
-      result = generate_sitemap(host_for_sitemap)
-
-      @logger.log "Bookbinder bound your book into #{final_app_dir.to_s.green}"
-
-      !result.has_broken_links?
-    end
-
-    private
-
-    attr_reader :section_repository, :logger, :file_system_accessor, :sitemap_writer
-
-    def generate_sitemap(host_for_sitemap)
-      raise "Your public host must be a single String." unless host_for_sitemap.is_a?(String)
-      sitemap_writer.write(host_for_sitemap)
-    end
-
-    def generate_site(cli_options, output_paths, publish_config, middleman_dir, workspace_dir, subnavs, build_dir, public_dir)
-      @static_site_generator.run(middleman_dir,
-                                 workspace_dir,
-                                 publish_config.fetch(:template_variables, {}),
-                                 output_paths.local_repo_dir,
-                                 cli_options[:verbose],
-                                 subnavs,
-                                 publish_config[:host_for_sitemap],
-                                 publish_config[:archive_menu])
-      file_system_accessor.copy build_dir, public_dir
-    end
-  end
-end

data/lib/bookbinder/user_message_presenter.rb

@@ -1,21 +0,0 @@
-require_relative 'colorizer'
-
-module Bookbinder
-  class UserMessagePresenter
-    def initialize(colorizer)
-      @colorizer = colorizer
-    end
-
-    def get_error(user_message)
-      colorizer.colorize(user_message.message, Colorizer::Colors.red)
-    end
-
-    def get_warning(user_message)
-      colorizer.colorize(user_message.message, Colorizer::Colors.yellow)
-    end
-
-    private
-
-    attr_reader :colorizer
-  end
-end