bookbindery 1.0.0

data/lib/bookbinder/css_link_checker.rb

@@ -0,0 +1,64 @@
+require 'css_parser'
+require_relative 'spider'
+
+module Bookbinder
+  class CssLinkChecker
+    def broken_links_in_all_stylesheets
+      localized_links_in_stylesheets.reject { |link| target_exists?(link) }
+    end
+
+    private
+
+    def localized_links_in_stylesheets
+      links_in_stylesheets = []
+      Dir.glob('**/*.css').each { |stylesheet| links_in_stylesheets.concat localized_links_from(stylesheet) }
+
+      links_in_stylesheets
+    end
+
+    def localized_links_from(stylesheet)
+      localized_uris = []
+      css = CssParser::Parser.new
+      css.load_uri! stylesheet
+
+      css.each_selector do |s, declaration, sp|
+        contents_of_url_value = /url\((.*?)\)/
+        file_url = declaration.match contents_of_url_value
+        localized_uris << Spider.prepend_location(stylesheet, file_url[1]) if file_url
+      end
+
+      localized_uris
+    end
+
+    def target_exists?(localized_identifier)
+      dirs, link = strip_location(localized_identifier)
+      link.gsub!(/'|"/, '')
+
+      data_uri      = /^['"]?data:image\//
+      remote_uri    = /^['"]?https?:\/\//
+      absolute_uri  = /^['"]?\//
+      relative_uri  = //
+
+      case link
+        when data_uri then true
+        when remote_uri then http_reachable?(link)
+        when absolute_uri then File.exists?(File.join('.', 'public', link))
+        when relative_uri then
+          dirs = dirs.split('/')[0...-1]
+          computed_uri = File.expand_path(File.join dirs, link)
+          File.exists?(computed_uri)
+      end
+    end
+
+    def strip_location(id)
+      dirs, filepath = id.split('=> ')
+      [dirs, filepath]
+    end
+
+    def http_reachable?(link)
+      Net::HTTP.get_response(URI(link)).code == '200'
+    rescue SocketError => e
+      return false
+    end
+  end
+end

data/lib/bookbinder/directory_helpers.rb

@@ -0,0 +1,15 @@
+module Bookbinder
+  module DirectoryHelperMethods
+
+    private
+
+    def output_dir_name
+      'output'
+    end
+
+    def source_dir_name
+      'source'
+    end
+
+  end
+end

data/lib/bookbinder/distributor.rb

@@ -0,0 +1,69 @@
+require_relative 'app_fetcher'
+
+module Bookbinder
+  class Distributor
+    EXPIRATION_HOURS = 2
+
+    def self.build(logger, options)
+      namespace = GitHubRepository.new(logger: logger, full_name: options[:book_repo]).short_name
+      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)
+      cf_command_runner = CfCommandRunner.new(logger, options[:cf_credentials], namer.full_path)
+      cf_app_fetcher = AppFetcher.new(options[:cf_credentials].flat_routes, cf_command_runner)
+
+      pusher = Pusher.new(cf_command_runner, cf_app_fetcher)
+      new(logger, archive, pusher, namespace, namer, options)
+    end
+
+    def initialize(logger, archive, pusher, namespace, namer, options)
+      @logger = logger
+      @archive = archive
+      @pusher = pusher
+      @namespace = namespace
+      @namer = namer
+      @options = options
+    end
+
+    def distribute
+      begin
+        download if options[:production]
+        push_app
+        nil
+      rescue => e
+        cf_credentials = options[:cf_credentials]
+        cf_space = options[:production] ? cf_credentials.production_space : cf_credentials.staging_space
+        cf_routes = options[:production] ? cf_credentials.production_host : cf_credentials.staging_host
+        @logger.error "[ERROR] #{e.message}\n[DEBUG INFO]\nCF organization: #{cf_credentials.organization}\nCF space: #{cf_space}\nCF account: #{cf_credentials.username}\nroutes: #{cf_routes}"
+      ensure
+        upload_trace
+      end
+    end
+
+    private
+
+    attr_reader :options, :archive, :namer, :namespace, :pusher
+
+    def download
+      archive.download(download_dir: options[:app_dir], bucket: options[:aws_credentials].green_builds_bucket, build_number: options[:build_number],
+                       namespace: namespace)
+    end
+
+    def push_app
+      warn if options[:production]
+      pusher.push(options[:app_dir])
+    end
+
+    def upload_trace
+      uploaded_file = archive.upload_file(options[:aws_credentials].green_builds_bucket, namer.filename, namer.full_path)
+      @logger.log("Your cf trace file is available at: #{uploaded_file.url(Time.now.to_i + EXPIRATION_HOURS*60*60).green}")
+      @logger.log("This URL will expire in #{EXPIRATION_HOURS} hours, so if you need to share it, make sure to save a copy now.")
+    rescue Errno::ENOENT
+      @logger.error "Could not find CF trace file: #{namer.full_path}"
+    end
+
+    def warn
+      @logger.warn 'Warning: You are pushing to CF Docs production. Be careful.'
+    end
+  end
+end

data/lib/bookbinder/git_client.rb

@@ -0,0 +1,63 @@
+require 'octokit'
+
+module Bookbinder
+  class GitClient < Octokit::Client
+    class GitClient::TokenException < StandardError;
+    end
+
+    def initialize(logger, *args)
+      @logger = logger
+      super(*args)
+    end
+
+    def head_sha(full_name)
+      commits(full_name).first.sha
+    end
+
+    def create_tag!(full_name, tagname, ref)
+      @logger.log 'Tagging ' + full_name.cyan
+      tag_result = create_tag(full_name, "tags/#{tagname}", 'Tagged by Bookbinder', ref, 'commit', 'Bookbinder', 'bookbinder@cloudfoundry.org', Time.now.iso8601)
+      create_ref(full_name, "tags/#{tagname}", tag_result.sha)
+    rescue Octokit::Unauthorized, Octokit::NotFound
+      raise_error_with_context
+    end
+
+    def archive_link(*args)
+      super
+    rescue Octokit::Unauthorized, Octokit::NotFound
+      raise_error_with_context
+    end
+
+    def tags(*args)
+      super
+    rescue Octokit::Unauthorized, Octokit::NotFound
+      raise_error_with_context
+    end
+
+    def refs(*args)
+      super
+    rescue Octokit::Unauthorized, Octokit::NotFound
+      raise_error_with_context
+    end
+
+    def last_modified_date_of(full_name, target_ref, file)
+      commits = commits(full_name, target_ref, path: file)
+      commits.first[:commit][:author][:date]
+    end
+
+    private
+
+    def commits(*args)
+      super
+    rescue Octokit::Unauthorized, Octokit::NotFound
+      raise_error_with_context
+    end
+
+    def raise_error_with_context
+      absent_token_message = '  Cannot access repository! You must set $GITHUB_API_TOKEN.'
+      invalid_token_message = '  Cannot access repository! Does your $GITHUB_API_TOKEN have access to this repository? Does it exist?'
+
+      ENV['GITHUB_API_TOKEN'] ? raise(TokenException.new(invalid_token_message)) : raise(TokenException.new(absent_token_message))
+    end
+  end
+end

data/lib/bookbinder/git_hub_repository.rb

@@ -0,0 +1,151 @@
+require 'ruby-progressbar'
+require 'bookbinder/shell_out'
+require 'git'
+require_relative 'git_client'
+require_relative 'bookbinder_logger'
+
+module Bookbinder
+  class GitHubRepository
+    class RepositoryCloneError < StandardError
+      def initialize(msg=nil)
+        super
+      end
+    end
+
+    include Bookbinder::ShellOut
+
+    attr_reader :full_name, :copied_to
+
+    def self.build_from_remote(logger, section_hash, destination_dir, target_ref, git_accessor)
+      full_name = section_hash.fetch('repository', {}).fetch('name')
+      target_ref = target_ref || section_hash.fetch('repository', {})['ref']
+      directory = section_hash['directory']
+      repository = new(logger: logger, full_name: full_name, target_ref: target_ref, github_token: ENV['GITHUB_API_TOKEN'], directory: directory)
+      repository.copy_from_remote(destination_dir, git_accessor) if destination_dir
+      repository
+    end
+
+    def self.build_from_local(logger, section_hash, local_repo_dir, destination_dir)
+      full_name = section_hash.fetch('repository').fetch('name')
+      directory = section_hash['directory']
+
+      repository = new(logger: logger, full_name: full_name, directory: directory, local_repo_dir: local_repo_dir)
+      repository.copy_from_local(destination_dir) if destination_dir
+
+      repository
+    end
+
+    def initialize(logger: nil, full_name: nil, target_ref: nil, github_token: nil, directory: nil, local_repo_dir: nil)
+      @logger = logger
+      #TODO better error message
+      raise 'No full_name provided ' unless full_name
+      @full_name = full_name
+      @github = GitClient.new(logger, access_token: github_token || ENV['GITHUB_API_TOKEN'])
+      @target_ref = target_ref
+      @directory = directory
+      @local_repo_dir = local_repo_dir
+    end
+
+    def tag_with(tagname)
+      @github.create_tag! full_name, tagname, head_sha
+    end
+
+    def short_name
+      full_name.split('/')[1]
+    end
+
+    def head_sha
+      @head_sha ||= @github.head_sha(full_name)
+    end
+
+    def directory
+      @directory || short_name
+    end
+
+    def copy_from_remote(destination_dir, git_accessor = Git)
+      begin
+        @git = git_accessor.clone("git@github.com:#{full_name}", directory, path: destination_dir)
+      rescue => e
+        if e.message.include? "Permission denied (publickey)"
+          raise RepositoryCloneError.new "Unable to access repository #{full_name}. You do not have the correct access rights. Please either add the key to your SSH agent, or set the GIT_SSH environment variable to override default SSH key usage. For more information run: `man git`."
+        elsif
+          e.message.include? "Repository not found."
+          raise RepositoryCloneError.new "Could not read from repository. Please make sure you have the correct access rights and the repository #{full_name} exists."
+        else
+          raise e
+        end
+      end
+      @git.checkout(target_ref) unless target_ref == 'master'
+      @copied_to = destination_dir
+    end
+
+    def copy_from_local(destination_dir)
+      if File.exist?(path_to_local_repo)
+        @logger.log '  copying '.yellow + path_to_local_repo
+        destination = File.join(destination_dir, directory)
+
+        unless destination.include?(path_to_local_repo)
+          FileUtils.mkdir_p(destination)
+          FileUtils.cp_r(File.join(path_to_local_repo, '.'), destination)
+        end
+
+        @copied_to = File.join(destination_dir, directory)
+      else
+        announce_skip
+      end
+    end
+
+    def copied?
+      !@copied_to.nil?
+    end
+
+    def has_tag?(tagname)
+      tags.any? { |tag| tag.name == tagname }
+    end
+
+    def update_local_copy
+      if File.exist?(path_to_local_repo)
+        @logger.log 'Updating ' + path_to_local_repo.cyan
+        Kernel.system("cd #{path_to_local_repo} && git pull")
+      else
+        announce_skip
+      end
+    end
+
+    def announce_skip
+      @logger.log '  skipping (not found) '.magenta + path_to_local_repo
+    end
+
+    def get_modification_date_for(file: nil, git: nil)
+      @git ||= git
+      raise "Unexpected Error: Git accessor unavailable." if @git.nil?
+
+      irrelevant_path_component = directory+'/'
+      repo_path = file.gsub(irrelevant_path_component, '')
+
+      begin
+        @git.log(1).object(repo_path).first.date
+      rescue Git::GitExecuteError => e
+        raise "This file does not exist or is not tracked by git! Cannot get last modified date for #{repo_path}."
+      end
+    end
+
+    def path_to_local_repo
+      File.join(@local_repo_dir, short_name)
+    end
+
+    def has_git_object?
+      !!@git
+    end
+
+    private
+
+    def target_ref
+      @target_ref ||= 'master'
+    end
+
+    def tags
+      @github.tags @full_name
+    end
+  end
+end

data/lib/bookbinder/local_file_system_accessor.rb

@@ -0,0 +1,9 @@
+module Bookbinder
+
+  class LocalFileSystemAccessor
+    def file_exist?(path)
+      File.exist?(path)
+    end
+  end
+
+end

data/lib/bookbinder/middleman_runner.rb

@@ -0,0 +1,86 @@
+require 'middleman-core'
+require 'middleman-core/cli'
+require 'middleman-core/profiling'
+require_relative 'code_example'
+
+class Middleman::Cli::BuildAction
+  def handle_error(file_name, response, e=Thor::Error.new(response))
+    our_errors = [Bookbinder::GitClient::TokenException,
+                  Bookbinder::CodeExample::InvalidSnippet,
+                  QuicklinksRenderer::BadHeadingLevelError,
+                  Git::GitExecuteError]
+    raise e if our_errors.include?(e.class)
+
+    original_handle_error(e, file_name, response)
+  end
+
+  private
+
+  def original_handle_error(e, file_name, response)
+    base.had_errors = true
+
+    base.say_status :error, file_name, :red
+    if base.debugging
+      raise e
+      exit(1)
+    elsif base.options["verbose"]
+      base.shell.say response, :red
+    end
+  end
+end
+
+module Bookbinder
+  class MiddlemanRunner
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def run(middleman_dir, template_variables, local_repo_dir, verbose = false, book = nil, sections = [], production_host=nil, archive_menu=nil, git_accessor=Git)
+      @logger.log "\nRunning middleman...\n\n"
+
+      within(middleman_dir) do
+        invoke_against_current_dir(local_repo_dir, production_host, book, sections, template_variables, archive_menu, verbose, git_accessor)
+      end
+    end
+
+    private
+
+    def within(temp_root, &block)
+      Middleman::Cli::Build.instance_variable_set(:@_shared_instance, nil)
+      original_mm_root  = ENV['MM_ROOT']
+      ENV['MM_ROOT']    = temp_root
+
+      Dir.chdir(temp_root) { block.call }
+
+      ENV['MM_ROOT']    = original_mm_root
+    end
+
+    def invoke_against_current_dir(local_repo_dir, production_host, book, sections, template_variables, archive_menu, verbose, git_accessor)
+      builder = Middleman::Cli::Build.shared_instance(verbose)
+
+      config = {
+          local_repo_dir: local_repo_dir,
+          production_host: production_host,
+          git_accessor: git_accessor,
+          sections: sections,
+          book: book,
+          template_variables: template_variables,
+          relative_links: false,
+          subnav_templates: subnavs_by_dir_name(sections),
+          archive_menu: archive_menu
+      }
+
+      config.each { |k, v| builder.config[k] = v }
+      Middleman::Cli::Build.new([], {quiet: !verbose}, {}).invoke :build, [], {verbose: verbose}
+    end
+
+    def subnavs_by_dir_name(sections)
+      sections.reduce({}) do |final_map, section|
+        namespace = section.directory.gsub('/', '_')
+        template = section.subnav_template || 'default'
+
+        final_map.merge(namespace => template)
+      end
+    end
+  end
+end