bookwatch 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 686b95008877c126bfe9af603a9897343618f85e
+  data.tar.gz: eba03326cca45031e7bb2b238efc7a23fdc3135d
+SHA512:
+  metadata.gz: abfdc87b7c3ee117b69b51e8800f9140a7574f91677e7459306725af103cd6c9e5fed1517e8b02218ed3d98419cfaef6ae320630621c5d80701500e2895107e2
+  data.tar.gz: 9b6c38bee013251cfb7fdb52bb340fef1c4f592f55899b8624507f835749f90b8ebe346145df7c97cef6f572939b952b2366d8dd621e2de052916f3014d34f18

data/bookwatch.gemspec

@@ -0,0 +1,40 @@
+require 'base64'
+
+Gem::Specification.new do |s|
+  s.name        = 'bookwatch'
+  s.version     = '1.0.0'
+  s.summary     = 'Bookbinder with everything disabled except the watch function'
+  s.description = 'A command line utility to be run in Book repositories to stitch together their constituent Markdown repos into a temporary static-HTML-serving application'
+  s.authors     = ['Mike Grafton', 'Lucas Marks', 'Gavin Morgan', 'Nikhil Gajwani', 'Dan Wendorf', 'Brenda Chan', 'Matthew Boedicker', 'Andrew Bruce', 'Frank Kotsianas', 'Elena Sharma', 'Christa Hartsock', 'Michael Trestman', 'Alpha Chen', 'Sarah McAlear', 'Gregg Van Hove']
+  s.email       = Base64.decode64('Z21vcmdhbkBnb3Bpdm90YWwuY29t') # Gavin's
+  s.files       = Dir['lib/**/*'] + Dir['template_app/**/*'] + Dir['master_middleman/**/*'] + Dir['install_bin/bookwatch'] + Dir['bookwatch.gemspec']
+  s.homepage    = 'https://github.com/pivotal-cf/bookbinder'
+  s.license     = 'MIT'
+  s.bindir      = 'install_bin'
+  s.executable  = 'bookwatch'
+
+  s.required_ruby_version = '>= 2.0.0'
+  s.add_runtime_dependency 'fog-aws', ['~> 0.7.1']
+  s.add_runtime_dependency 'ansi', ['~> 1.4']
+  s.add_runtime_dependency 'middleman', ['~> 3.4.0']
+  s.add_runtime_dependency 'middleman-livereload', ['~> 3.4.3']
+  s.add_runtime_dependency 'middleman-syntax', ['~> 2.0']
+  s.add_runtime_dependency 'rouge', '!= 1.9.1'
+  s.add_runtime_dependency 'redcarpet', ['~> 3.2.3']
+  s.add_runtime_dependency 'css_parser'
+  s.add_runtime_dependency 'puma'
+  s.add_runtime_dependency 'rack-rewrite'
+  s.add_runtime_dependency 'therubyracer'
+  s.add_runtime_dependency 'git', '~> 1.2.8'
+  s.add_runtime_dependency 'nokogiri', ['1.6.7.2']
+  s.add_runtime_dependency 'thor'
+  s.add_runtime_dependency 'elasticsearch'
+  s.add_runtime_dependency 'font-awesome-sass'
+
+  s.add_development_dependency 'license_finder'
+  s.add_development_dependency 'pry-byebug'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'sendgrid-ruby', '< 3.0'
+  s.add_development_dependency 'jasmine'
+end

data/install_bin/bookwatch

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/bookwatch/cli'
+
+Bookwatch::CLI.start

data/lib/bookwatch/cli.rb

@@ -0,0 +1,109 @@
+require 'thor'
+
+require_relative 'ingest/git_accessor'
+require_relative 'streams/colorized_stream'
+require_relative 'colorizer'
+require_relative 'commands/collection'
+
+module Bookwatch
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    map '--version' => :version
+    map '--help' => :help
+
+    desc '--version', 'Print the version of bookwatch'
+    def version
+      gemspec = File.expand_path('../../../bookwatch.gemspec', __FILE__)
+      say "bookwatch #{Gem::Specification::load(gemspec).version}"
+    end
+
+    desc '--help', 'Print this message'
+    def help(command=nil)
+      super
+    end
+
+=begin
+    desc 'generate <book_name>', 'DISABLED: Generate a skeleton book that can be bound with "bookwatch bind"'
+    def generate(book_name)
+      code = legacy_commands.generate(book_name)
+      raise Thor::Error, '' if code != 0
+    end
+
+    desc 'bind <local|remote> [options]', 'DISABLED: Bind the sections specified in config.yml from <local> or <remote> into the final_app directory'
+    option :verbose, type: :boolean
+    option 'dita-flags', desc: '--dita-flags=\"<dita-option>=<value>\"'
+    option :require_valid_subnav_links, type: :boolean, desc: 'Check that subnav link targets exist, always true for remote'
+    def bind(source)
+      code = legacy_commands.bind(source, options[:verbose], options['dita-flags'], options[:require_valid_subnav_links])
+      raise Thor::Error, '' if code != 0
+    end
+
+    desc 'punch <git tag>', 'DISABLED: Apply the specified <git tag> to your book, sections, and layout repo'
+    def punch(git_tag)
+      code = legacy_commands.punch(git_tag)
+      raise Thor::Error, '' if code != 0
+    end
+
+    desc 'update_local_doc_repos', 'DISABLED: Run `git pull` on all sections that exist at the same directory level as your book directory'
+    def update_local_doc_repos
+      code = legacy_commands.update_local_doc_repos
+      raise Thor::Error, '' if code != 0
+    end
+=end
+
+    desc 'watch [repo1 [repo2]]', 'Bind and serve a local book, watching for changes'
+    long_desc <<-LONG_DESC
+Bind and serve a local book, watching for changes
+
+Optionally, you can provide a subset of the repositories in the book to be watched.
+This will exclude any repositories not specified from being available in the bound book, even if they exist on your file system.
+    LONG_DESC
+    def watch(*repos)
+      code = legacy_commands.watch(repos)
+      raise Thor::Error, '' if code != 0
+    end
+
+=begin
+    desc 'imprint <local|remote> [options]', 'DISABLED: Generate a PDF for a given book'
+    option :verbose, type: :boolean
+    option 'dita-flags', desc: '--dita-flags=\"<dita-option>=<value>\"'
+    def imprint(source)
+      code = legacy_commands.imprint(source, options[:verbose], options['dita-flags'])
+      raise Thor::Error, '' if code != 0
+    end
+
+    def method_missing(command, *args)
+      puts "Unknown command '#{command}'"
+      puts ""
+      help
+    end
+
+    private
+
+    attr_reader :legacy_commands
+
+    def initialize(*)
+      super
+
+      @legacy_commands = Bookwatch::Commands::Collection.new(colorized_streams, git)
+    end
+
+    def git
+      @git ||= Ingest::GitAccessor.new
+    end
+
+    def colorized_streams
+      @streams ||= {
+        err: Streams::ColorizedStream.new(Colorizer::Colors.red, $stderr),
+        out: $stdout,
+        success: Streams::ColorizedStream.new(Colorizer::Colors.green, $stdout),
+        warn: Streams::ColorizedStream.new(Colorizer::Colors.yellow, $stdout),
+      }
+    end
+=end
+
+  end
+end

data/lib/bookwatch/code_example_reader.rb

@@ -0,0 +1,95 @@
+module Bookwatch
+  class CodeExampleReader
+    class InvalidSnippet < StandardError
+      def initialize(repo, marker)
+        super "Error with marker #{marker} in #{repo}."
+      end
+    end
+
+    def initialize(streams, fs)
+      @out = streams[:out]
+      @fs = fs
+    end
+
+    def get_snippet_and_language_at(marker, working_copy)
+      if working_copy.available?
+        process_snippet(marker, working_copy)
+      else
+        out.puts("  skipping (not found) #{working_copy.full_name}")
+        ''
+      end
+    end
+
+    class Snippet
+      def initialize(text, language_pattern)
+        @text = text
+        @language_pattern = language_pattern
+      end
+
+      def valid?
+        ! text.empty?
+      end
+
+      def language
+        language_match = lines[0].match(language_pattern)
+        Array(language_match)[1]
+      end
+
+      def content
+        lines[1..-2].join("\n").strip
+      end
+
+      private
+
+      attr_reader :text, :language_pattern
+
+      def lines
+        text.split("\n")
+      end
+    end
+
+    private
+
+    attr_reader :out, :fs
+
+    def process_snippet(marker, working_copy)
+      snippet = Snippet.new(
+        find_text(working_copy.path, pattern_for(marker)),
+        language_pattern_for(marker)
+      )
+      if snippet.valid?
+        [snippet.content, snippet.language]
+      else
+        raise InvalidSnippet.new(working_copy.full_name, marker)
+      end
+    end
+
+    def find_text(start_path, pattern)
+      fs.find_files_recursively(start_path).
+        lazy.
+        select {|path| fs.file_exist?(path) }.
+        map {|path| fs.read(path) }.
+        map {|contents|
+          begin
+            contents.scan(pattern)
+          rescue ArgumentError => e
+            cannot_scan
+          end
+        }.
+        map(&:first).
+        detect ->{""} {|text| text}
+    end
+
+    def pattern_for(marker)
+      /code_snippet #{Regexp.escape(marker)} start.*code_snippet #{Regexp.escape(marker)} end/m
+    end
+
+    def language_pattern_for(marker)
+      /code_snippet #{Regexp.escape(marker)} start (\w+)/
+    end
+
+    def cannot_scan
+      []
+    end
+  end
+end

data/lib/bookwatch/colorizer.rb

@@ -0,0 +1,16 @@
+require 'ansi/code'
+require 'ostruct'
+
+module Bookwatch
+  class Colorizer
+    Colors = OpenStruct.new(
+      green: ->(msg) { ANSI.green {msg} },
+      red: ->(msg) { ANSI.red {msg} },
+      yellow: ->(msg) { ANSI.yellow {msg} },
+    )
+
+    def colorize(string, color)
+      color.call string.to_s
+    end
+  end
+end

data/lib/bookwatch/commands/bind.rb

@@ -0,0 +1,119 @@
+require 'middleman-syntax'
+
+require_relative 'components/command_options'
+
+module Bookwatch
+  module Commands
+    class Bind
+      def initialize(base_streams,
+                     output_locations: nil,
+                     config_fetcher: nil,
+                     config_decorator: nil,
+                     file_system_accessor: nil,
+                     middleman_runner: nil,
+                     link_checker: nil,
+                     preprocessor: nil,
+                     cloner_factory: nil,
+                     section_repository: nil,
+                     directory_preparer: nil)
+
+        @base_streams = base_streams
+        @output_locations = output_locations
+        @config_fetcher = config_fetcher
+        @config_decorator = config_decorator
+        @file_system_accessor = file_system_accessor
+        @middleman_runner = middleman_runner
+        @link_checker = link_checker
+        @preprocessor = preprocessor
+        @cloner_factory = cloner_factory
+        @section_repository = section_repository
+        @directory_preparer = directory_preparer
+      end
+
+      def run(bind_type, verbose = false, dita_flags = nil, require_valid_subnav_links = false)
+        bind_options        = Components::CommandOptions.new([bind_type], base_streams, verbose)
+        bind_config         = config_fetcher.fetch_config
+        cloner              = cloner_factory.produce(bind_options.local_repo_dir)
+
+        require_valid_subnav_links = true unless bind_type == 'local'
+
+        directory_preparer.prepare_directories(
+          bind_config,
+          File.expand_path('../../../../', __FILE__),
+          output_locations,
+          cloner,
+          ref_override: bind_options.ref_override
+        )
+
+        sections = section_repository.fetch(
+          configured_sections: bind_config.sections,
+          destination_dir: output_locations.cloned_preprocessing_dir,
+          ref_override: bind_options.ref_override,
+          cloner: cloner,
+          streams: base_streams
+        )
+        preprocessor.preprocess(
+          sections,
+          output_locations,
+          options: { dita_flags: dita_flags, require_valid_subnav_links: require_valid_subnav_links },
+          output_streams: bind_options.streams,
+          config: bind_config
+        )
+        if file_system_accessor.file_exist?('redirects.rb')
+          file_system_accessor.copy('redirects.rb', output_locations.final_app_dir)
+        end
+
+        generation_result = middleman_runner.run(
+          'build --verbose',
+          streams: bind_options.streams,
+          output_locations: output_locations,
+          config: config_decorator.generate(bind_config, sections),
+          local_repo_dir: bind_options.local_repo_dir,
+          subnavs: subnavs(sections),
+          product_info: product_infos(sections)
+        )
+        if generation_result.success?
+          file_system_accessor.copy(output_locations.build_dir, output_locations.public_dir)
+
+          link_checker.check!(bind_config.broken_link_exclusions)
+
+          bind_options.streams[:success].puts "Bookwatch bound your book into #{output_locations.final_app_dir}"
+
+          link_checker.has_errors? ? 1 : 0
+        else
+          bind_options.streams[:err].puts "Your bind failed. Rerun with --verbose to troubleshoot."
+          1
+        end
+      end
+
+      private
+
+      attr_reader(
+        :base_streams,
+        :cloner_factory,
+        :config_decorator,
+        :config_fetcher,
+        :directory_preparer,
+        :file_system_accessor,
+        :final_app_directory,
+        :output_locations,
+        :preprocessor,
+        :section_repository,
+        :link_checker,
+        :middleman_runner,
+      )
+
+      def subnavs(sections)
+        sections.map(&:subnav).reduce({}, :merge)
+      end
+
+      def product_infos(sections)
+        temp = Hash.new
+        sections.each do |section|
+          temp[section.namespace] = section.product_info
+        end
+        temp
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/collection.rb

@@ -0,0 +1,181 @@
+Dir.glob(File.expand_path('../../commands/*.rb', __FILE__)).each do |command_file|
+  require command_file unless command_file =~ /collection\.rb\z/
+end
+
+require_relative '../commands/components/bind/directory_preparer'
+require_relative '../commands/components/imprint/directory_preparer'
+require_relative '../config/configuration_decorator'
+require_relative '../config/fetcher'
+require_relative '../config/validator'
+require_relative '../config/yaml_loader'
+require_relative '../config/configuration'
+require_relative '../config/imprint/configuration'
+require_relative '../dita_command_creator'
+require_relative '../dita_html_for_middleman_formatter'
+require_relative '../html_document_manipulator'
+require_relative '../ingest/cloner_factory'
+require_relative '../ingest/section_repository'
+require_relative '../local_filesystem_accessor'
+require_relative '../middleman_runner'
+require_relative '../postprocessing/link_checker'
+require_relative '../preprocessing/dita_html_preprocessor'
+require_relative '../preprocessing/dita_pdf_preprocessor'
+require_relative '../preprocessing/link_to_site_gen_dir'
+require_relative '../preprocessing/preprocessor'
+require_relative '../subnav/subnav_generator_factory'
+require_relative '../sheller'
+require_relative '../values/output_locations'
+
+module Bookwatch
+  module Commands
+    class Collection
+      include Enumerable
+
+      def initialize(streams, version_control_system)
+        @streams = streams
+        @version_control_system = version_control_system
+      end
+
+      def generate(*args)
+        Commands::Generate.new(
+          local_filesystem_accessor,
+          sheller,
+          Dir.pwd,
+          streams
+        ).run(*args)
+      end
+
+      def punch(*args)
+        Commands::Punch.new(
+          streams,
+          configuration_fetcher(Config::Configuration),
+          version_control_system
+        ).run(*args)
+      end
+
+      def update_local_doc_repos
+        Commands::UpdateLocalDocRepos.new(
+          streams,
+          configuration_fetcher(Config::Configuration),
+          version_control_system
+        ).run
+      end
+
+      def bind(*args)
+        @bind ||= Commands::Bind.new(
+          streams,
+          middleman_runner: runner,
+          output_locations: output_locations,
+          config_fetcher: configuration_fetcher(Config::Configuration),
+          config_decorator: Config::ConfigurationDecorator.new(loader: config_loader, config_filename: 'bookwatch.yml'),
+          file_system_accessor: local_filesystem_accessor,
+          link_checker: Postprocessing::LinkChecker.new(local_filesystem_accessor, final_app_directory, streams),
+          preprocessor: Preprocessing::Preprocessor.new(
+            Preprocessing::DitaHTMLPreprocessor.new(
+              local_filesystem_accessor,
+              subnav_generator_factory,
+              DitaHtmlForMiddlemanFormatter.new(local_filesystem_accessor, html_document_manipulator),
+              dita_command_creator,
+              sheller
+            ),
+            Preprocessing::LinkToSiteGenDir.new(local_filesystem_accessor, subnav_generator_factory)
+          ),
+          cloner_factory: Ingest::ClonerFactory.new(streams, local_filesystem_accessor, version_control_system),
+          section_repository: Ingest::SectionRepository.new,
+          directory_preparer: directory_preparer
+        ).run(*args)
+      end
+
+      def watch(repos=[])
+        @watch ||= Commands::Watch.new(
+          streams,
+          middleman_runner: runner,
+          output_locations: output_locations,
+          config_fetcher: configuration_fetcher(Config::Configuration),
+          config_decorator: Config::ConfigurationDecorator.new(loader: config_loader, config_filename: 'bookwatch.yml'),
+          file_system_accessor: local_filesystem_accessor,
+          preprocessor: Preprocessing::Preprocessor.new(Preprocessing::LinkToSiteGenDir.new(local_filesystem_accessor, subnav_generator_factory)),
+          cloner: local_file_system_cloner,
+          section_repository: Ingest::SectionRepository.new,
+          directory_preparer: directory_preparer,
+          repo_restrictions: repos
+        ).run
+      end
+
+      def imprint(*args)
+        Bookwatch::Commands::Imprint.new(
+          streams,
+          output_locations: output_locations,
+          config_fetcher: configuration_fetcher(Config::Imprint::Configuration),
+          preprocessor: Preprocessing::Preprocessor.new(Preprocessing::DitaPDFPreprocessor.new(local_filesystem_accessor, dita_command_creator, sheller)),
+          cloner_factory: Ingest::ClonerFactory.new(streams, local_filesystem_accessor, version_control_system),
+          section_repository: Ingest::SectionRepository.new,
+          directory_preparer: Commands::Components::Imprint::DirectoryPreparer.new(local_filesystem_accessor)
+        ).run(*args)
+      end
+
+      private
+
+      attr_reader :streams, :version_control_system
+
+      def dita_command_creator
+        DitaCommandCreator.new(ENV['PATH_TO_DITA_OT_LIBRARY'])
+      end
+
+      def configuration_fetcher(config_class)
+        Bookwatch::Config::Fetcher.new(
+          Bookwatch::Config::Validator.new(local_filesystem_accessor),
+          config_loader,
+          config_class
+        ).tap do |fetcher|
+          fetcher.set_config_file_path './config.yml'
+          fetcher.set_config_dir_path './config/'
+        end
+      end
+
+      def config_loader
+        @config_loader ||= Config::YAMLLoader.new
+      end
+
+      def subnav_generator_factory
+        Subnav::SubnavGeneratorFactory.new(local_filesystem_accessor, output_locations)
+      end
+
+      def directory_preparer
+        Commands::Components::Bind::DirectoryPreparer.new(local_filesystem_accessor)
+      end
+
+      def output_locations
+        OutputLocations.new(final_app_dir: final_app_directory, context_dir: File.absolute_path('.'))
+      end
+
+      def final_app_directory
+        @final_app_directory ||= File.absolute_path('final_app')
+      end
+
+      def html_document_manipulator
+        @html_document_manipulator ||= HtmlDocumentManipulator.new
+      end
+
+      def local_filesystem_accessor
+        @local_filesystem_accessor ||= LocalFilesystemAccessor.new
+      end
+
+      def sheller
+        @sheller ||= Sheller.new
+      end
+
+      def sitemap_port
+        41722
+      end
+
+      def runner
+        MiddlemanRunner.new(local_filesystem_accessor, sheller)
+      end
+
+      def local_file_system_cloner
+        Ingest::LocalFilesystemCloner.new(streams, local_filesystem_accessor, File.expand_path('..'))
+      end
+    end
+  end
+end