bookwatch 1.0.0

data/lib/bookwatch/commands/components/bind/directory_preparer.rb

@@ -0,0 +1,33 @@
+require_relative 'layout_preparer'
+
+module Bookwatch
+  module Commands
+    module Components
+      module Bind
+        class DirectoryPreparer
+          def initialize(fs)
+            @fs = fs
+          end
+
+          def prepare_directories(config, gem_root, output_locations, cloner, ref_override: nil)
+            fs.remove_directory(output_locations.output_dir)
+            fs.empty_directory(output_locations.final_app_dir)
+
+            copy_directory_from_gem(gem_root, 'template_app', output_locations.final_app_dir)
+            copy_directory_from_gem(gem_root, 'master_middleman', output_locations.site_generator_home)
+
+            LayoutPreparer.new(fs).prepare(output_locations, cloner, ref_override, config)
+          end
+
+          private
+
+          attr_reader :fs
+
+          def copy_directory_from_gem(gem_root, dir, output_dir)
+            fs.copy_contents(File.join(gem_root, dir), output_dir)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/components/bind/layout_preparer.rb

@@ -0,0 +1,27 @@
+module Bookwatch
+  module Commands
+    module Components
+      module Bind
+        class LayoutPreparer
+          def initialize(fs)
+            @fs = fs
+          end
+
+          attr_reader :fs
+
+          def prepare(output_locations, cloner, ref_override, config)
+            if config.has_option?('layout_repo')
+
+              cloned_repo = cloner.call(source_repo_name: config.layout_repo,
+                                        source_ref: ref_override || config.layout_repo_ref,
+                                        destination_parent_dir: Dir.mktmpdir)
+
+              fs.copy_contents(cloned_repo.path, output_locations.site_generator_home)
+            end
+            fs.copy_contents(File.absolute_path('master_middleman'), output_locations.site_generator_home)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/components/command_options.rb

@@ -0,0 +1,45 @@
+require_relative '../../sheller'
+require_relative '../../colorizer'
+require_relative '../../streams/colorized_stream'
+require_relative '../../streams/filter_stream'
+
+module Bookwatch
+  module Commands
+    module Components
+      class CommandOptions
+        def initialize(opts, base_streams, verbose = false)
+          @opts = opts
+          @base_streams = base_streams
+          @verbosity = verbose
+        end
+
+        def bind_source
+          opts.first
+        end
+
+        def local_repo_dir
+          File.expand_path('..') if bind_source == 'local'
+        end
+
+        def options
+          opts[1..-1]
+        end
+
+        def ref_override
+          'master' if options.include?('--ignore-section-refs')
+        end
+
+        def streams
+          base_streams.merge(
+            out: verbosity ? base_streams[:out] :
+              Streams::FilterStream.new(/^(?:\s*error|Invalid CSS|Undefined mixin|\/)/i, Streams::ColorizedStream.new(Colorizer::Colors.red, base_streams[:out])),
+          )
+        end
+
+        private
+
+        attr_accessor :base_streams, :opts, :verbosity
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/components/imprint/directory_preparer.rb

@@ -0,0 +1,24 @@
+module Bookwatch
+  module Commands
+    module Components
+      module Imprint
+        class DirectoryPreparer
+          def initialize(fs)
+            @fs = fs
+          end
+
+          def prepare_directories(output_locations)
+            fs.empty_directory(output_locations.output_dir)
+            fs.make_directory(output_locations.pdf_from_preprocessing_dir)
+
+            fs.empty_directory(output_locations.pdf_artifact_dir)
+          end
+
+          private
+
+          attr_reader :fs
+        end
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/generate.rb

@@ -0,0 +1,92 @@
+require 'bundler'
+
+module Bookwatch
+  module Commands
+    class Generate
+      def initialize(fs, sheller, context_dir, streams)
+        @fs = fs
+        @sheller = sheller
+        @context_dir = context_dir
+        @streams = streams
+      end
+
+      def run(name, special_bookwatch_gem_args={})
+        path = context_dir.join(name)
+        streams[:out].puts "Generating book at #{path}..."
+        if fs.file_exist?(path)
+          streams[:err].puts "Cannot generate book: directory already exists"
+          1
+        elsif install(path, special_bookwatch_gem_args).success?
+          streams[:success].puts "Successfully generated book at #{path}"
+          0
+        else
+          1
+        end
+      end
+
+      private
+
+      attr_reader :fs, :sheller, :streams
+
+      def install(path, special_bookwatch_gem_args)
+        make_middleman_dir(path)
+        init_gemfile(path, special_bookwatch_gem_args)
+        init_config(path)
+        init_index(path)
+        bundle_install(path)
+      end
+
+      def make_middleman_dir(path)
+        fs.make_directory(path.join('master_middleman/build'))
+      end
+
+      def init_gemfile(path, special_bookwatch_gem_args)
+        bookwatch_config = ''
+
+        unless special_bookwatch_gem_args.empty?
+          config = special_bookwatch_gem_args.first
+          bookwatch_config = ", #{config.first}: \"#{config.last}\""
+        end
+
+        fs.write(
+          text: <<-GEMFILE,
+source "https://rubygems.org"
+
+gem "bookwatch"#{bookwatch_config}
+          GEMFILE
+          to: path.join('Gemfile')
+        )
+      end
+
+      def init_config(path)
+        fs.write(
+          text: YAML.dump(
+            'book_repo' => '',
+            'public_host' => '',
+          ),
+          to: path.join('config.yml')
+        )
+      end
+
+      def init_index(path)
+        fs.write(
+          text: '# Empty book',
+          to: path.join('master_middleman/source/index.md.erb')
+        )
+      end
+
+      def bundle_install(path)
+        Bundler.with_clean_env do
+          sheller.run_command(
+            "bundle install --binstubs --gemfile=#{path.join('Gemfile')}",
+            out: streams[:out], err: streams[:err]
+          )
+        end
+      end
+
+      def context_dir
+        Pathname(@context_dir)
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/imprint.rb

@@ -0,0 +1,55 @@
+require_relative 'components/command_options'
+
+module Bookwatch
+  module Commands
+    class Imprint
+      def initialize(base_streams,
+                     output_locations: nil,
+                     config_fetcher: nil,
+                     preprocessor: nil,
+                     cloner_factory: nil,
+                     section_repository: nil,
+                     directory_preparer: nil)
+
+        @base_streams = base_streams
+        @output_locations = output_locations
+        @config_fetcher = config_fetcher
+        @preprocessor = preprocessor
+        @cloner_factory = cloner_factory
+        @section_repository = section_repository
+        @directory_preparer = directory_preparer
+      end
+
+      def run(bind_type, verbose = false, dita_flags = nil)
+        options        = Components::CommandOptions.new([bind_type], base_streams, verbose)
+        config         = config_fetcher.fetch_config
+        cloner         = cloner_factory.produce(options.local_repo_dir)
+
+        directory_preparer.prepare_directories(output_locations)
+
+        sections = section_repository.fetch(
+          configured_sections: config.sections,
+          destination_dir: output_locations.cloned_preprocessing_dir,
+          ref_override: options.ref_override,
+          cloner: cloner,
+          streams: base_streams
+        )
+
+        preprocessor.preprocess(
+          sections,
+          output_locations,
+          options: { dita_flags: dita_flags },
+          output_streams: options.streams,
+          config: config
+        )
+
+        options.streams[:success].puts "Bookwatch printed your pdf(s) into #{output_locations.pdf_artifact_dir}"
+        0
+      end
+
+      private
+
+      attr_reader :preprocessor, :output_locations, :section_repository, :base_streams, :config_fetcher, :directory_preparer, :cloner_factory
+    end
+  end
+end

data/lib/bookwatch/commands/punch.rb

@@ -0,0 +1,33 @@
+module Bookwatch
+  module Commands
+    class Punch
+      def initialize(streams, configuration_fetcher, version_control_system)
+        @streams = streams
+        @configuration_fetcher = configuration_fetcher
+        @version_control_system = version_control_system
+      end
+
+      def run((tag, *))
+        urls(config).each do |url|
+          version_control_system.remote_tag(url, tag, 'HEAD')
+        end
+
+        streams[:success].puts 'Success!'
+        streams[:out].puts "#{config.book_repo} and its sections were tagged with #{tag}"
+        0
+      end
+
+      private
+
+      attr_reader :streams, :configuration_fetcher, :version_control_system
+
+      def urls(config)
+        [config.book_repo_url, config.layout_repo_url] + config.sections.map(&:repo_url).uniq
+      end
+
+      def config
+        @config ||= configuration_fetcher.fetch_config
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/update_local_doc_repos.rb

@@ -0,0 +1,42 @@
+require_relative '../ingest/destination_directory'
+
+module Bookwatch
+  module Commands
+    class UpdateLocalDocRepos
+      def initialize(streams, configuration_fetcher, version_control_system)
+        @streams = streams
+        @configuration_fetcher = configuration_fetcher
+        @version_control_system = version_control_system
+      end
+
+      def run
+        urls = configuration_fetcher.fetch_config.sections.map(&:repo_url)
+        paths(urls).each do |path|
+          streams[:out] << "\nUpdating #{path}:"
+          report(version_control_system.update(path))
+        end
+        streams[:out].puts
+        0
+      end
+
+      private
+
+      attr_reader(:streams,
+                  :configuration_fetcher,
+                  :version_control_system)
+
+      def report(result)
+        messages = { true => "updated", false => "skipping (#{result.reason})" }
+        streams[stream_types[result.success?]] << " #{messages[result.success?]}"
+      end
+
+      def stream_types
+        { true => :success, false => :out }
+      end
+
+      def paths(urls)
+        urls.map {|url| File.absolute_path("../#{Ingest::DestinationDirectory.new(url)}")}
+      end
+    end
+  end
+end

data/lib/bookwatch/commands/watch.rb

@@ -0,0 +1,100 @@
+module Bookwatch
+  module Commands
+    class Watch
+      def initialize(streams,
+                     middleman_runner: nil,
+                     output_locations: nil,
+                     config_fetcher: nil,
+                     config_decorator: nil,
+                     file_system_accessor: nil,
+                     preprocessor: nil,
+                     cloner: nil,
+                     section_repository: nil,
+                     directory_preparer: nil,
+                     repo_restrictions: [])
+        @streams = streams
+        @middleman_runner = middleman_runner
+        @output_locations = output_locations
+        @config_fetcher = config_fetcher
+        @config_decorator = config_decorator
+        @file_system_accessor = file_system_accessor
+        @preprocessor = preprocessor
+        @cloner = cloner
+        @section_repository = section_repository
+        @directory_preparer = directory_preparer
+        @repo_restrictions = repo_restrictions
+      end
+
+      def run
+        watch_config = config_fetcher.fetch_config
+
+        directory_preparer.prepare_directories(
+          watch_config,
+          File.expand_path('../../../../', __FILE__),
+          output_locations,
+          cloner
+        )
+        sections = section_repository.fetch(
+          configured_sections: filter_sections(watch_config.sections),
+          destination_dir: output_locations.cloned_preprocessing_dir,
+          cloner: cloner,
+          streams: streams
+        )
+        preprocessor.preprocess(
+          sections,
+          output_locations,
+          output_streams: streams,
+          config: watch_config
+        )
+        if file_system_accessor.file_exist?('redirects.rb')
+          file_system_accessor.copy('redirects.rb', output_locations.final_app_dir)
+        end
+
+        middleman_runner.run("server --force-polling --latency=5.0",
+          output_locations: output_locations,
+          config: config_decorator.generate(watch_config, sections),
+          local_repo_dir: File.expand_path('..'),
+          streams: streams,
+          subnavs: subnavs(sections),
+          product_info: product_infos(sections)
+        ).exitstatus
+      end
+
+      private
+
+      attr_reader(
+        :streams,
+        :middleman_runner,
+        :output_locations,
+        :config_fetcher,
+        :config_decorator,
+        :file_system_accessor,
+        :preprocessor,
+        :cloner,
+        :section_repository,
+        :directory_preparer
+      )
+
+      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
+
+      def filter_sections(section_configs)
+        return section_configs if @repo_restrictions.nil? || @repo_restrictions.empty?
+
+        section_configs.select do |config|
+          repo_name = (config.repo_name || '').split('/').last
+          @repo_restrictions.include?(repo_name)
+        end
+      end
+    end
+  end
+end