bookbindery 4.2.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23596356b5d99dfb4817501ce2347d9169249aac
-  data.tar.gz: 8a6c4f16b9d084462385d5e91c8639a0b64994f5
+  metadata.gz: 621e97dd76f614e82790228cfe022f204df2f3f3
+  data.tar.gz: 1555c3fe96a2231e0b850abfe6b7d98a7ca4b28e
 SHA512:
-  metadata.gz: 11458b7bd0d835303c8b32d61a692dbb72b8a39b724b05e32b75d07f77394f45520a47aa3f0aaa7c7797638388e527c2a78e358a0ae75b678ae2bdf217fcc1f4
-  data.tar.gz: f9f09e56be8ebef88f596f862c3652c803f036f83b1c50aada789ec099ffe8381aaffbe855836519116b2a5576b06ccbc2690ad4eeb7b2429e593b425b9446c4
+  metadata.gz: 1b22cdca4d39c048af425c48d3de76bfab47c923913d00b40f9212a59d37d60ad01a36c15932d13e9c4e7555ab65e91b5a0e0cad5b252513c3b7fc60c173f502
+  data.tar.gz: 49b94f81e1f08e00047e5ce6be496565ca39a34f6816cf11681795f055a25590418e80d313d493a888252aa6e82ef977e8786992b25a2cd5366fc68b9127b61d

data/lib/bookbinder/cli.rb

@@ -38,9 +38,6 @@ module Bookbinder
       begin
         command_runner.run command_name, command_arguments
 
-      rescue Config::RemoteBindConfiguration::VersionUnsupportedError => e
-        colorized_streams[:err].puts "config.yml at version '#{e.message}' has an unsupported API."
-        1
       rescue Config::CfCredentials::CredentialKeyError => e
         colorized_streams[:err].puts "#{e.message}, in credentials.yml"
         1

data/lib/bookbinder/code_example_reader.rb

@@ -6,16 +6,14 @@ module Bookbinder
       end
     end
 
-    def initialize(out: out)
-      @out = out
+    def initialize(streams, fs)
+      @out = streams[:out]
+      @fs = fs
     end
 
     def get_snippet_and_language_at(marker, working_copy)
-      snippet = Snippet.new(marker, working_copy)
-      if snippet.available? && !snippet.valid?
-        raise InvalidSnippet.new(working_copy.full_name, marker)
-      elsif snippet.available?
-        [snippet.content, snippet.language]
+      if working_copy.available?
+        process_snippet(marker, working_copy)
       else
         out << "  skipping (not found) #{working_copy.full_name}"
         ''
@@ -23,54 +21,74 @@ module Bookbinder
     end
 
     class Snippet
-      def initialize(marker, working_copy)
-        @marker = marker
-        @working_copy = working_copy
-      end
-
-      def available?
-        working_copy.available?
+      def initialize(text, language_pattern)
+        @text = text
+        @language_pattern = language_pattern
       end
 
       def valid?
-        ! get_snippet(marker, working_copy).empty?
+        ! text.empty?
       end
 
       def language
-        lines = get_snippet(marker, working_copy).split("\n")
-        language_match = lines[0].match(/code_snippet #{Regexp.escape(marker)} start (\w+)/)
+        language_match = lines[0].match(language_pattern)
         Array(language_match)[1]
       end
 
       def content
-        lines = get_snippet(marker, working_copy).split("\n")
-        lines[1..-2].join("\n")
+        lines[1..-2].join("\n").strip
       end
 
       private
 
-      attr_reader :marker, :working_copy
+      attr_reader :text, :language_pattern
 
-      def get_snippet(marker, working_copy)
-        @snippet ||=
-          begin
-            snippet = ''
-            FileUtils.cd(working_copy.path) {
-              locale = 'LC_CTYPE=C LANG=C' # Quiets 'sed: RE error: illegal byte sequence'
-              result = `#{locale} find . -exec sed -ne '/code_snippet #{marker} start/,/code_snippet #{marker} end/ p' {} \\; 2> /dev/null`
-              snippet = if result.lines.last && result.lines.last.match(/code_snippet #{marker} end/)
-                          result
-                        else
-                          ""
-                        end
-            }
-            snippet
-          end
+      def lines
+        text.split("\n")
       end
     end
 
     private
 
-    attr_reader :out
+    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.
+        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/bookbinder/commands/bind.rb

@@ -1,6 +1,5 @@
 require 'middleman-syntax'
 
-require_relative '../config/archive_menu_configuration'
 require_relative '../errors/cli_error'
 require_relative 'bind/bind_options'
 require_relative 'naming'
@@ -12,25 +11,25 @@ module Bookbinder
 
       def initialize(base_streams,
                      output_locations,
-                     config_factory,
-                     archive_menu_config,
+                     config_fetcher,
+                     config_decorator,
                      file_system_accessor,
                      static_site_generator,
                      sitemap_writer,
                      preprocessor,
                      cloner_factory,
-                     section_repository_factory,
+                     section_repository,
                      directory_preparer)
         @base_streams = base_streams
         @output_locations = output_locations
-        @config_factory = config_factory
-        @archive_menu_config = archive_menu_config
+        @config_fetcher = config_fetcher
+        @config_decorator = config_decorator
         @file_system_accessor = file_system_accessor
         @static_site_generator = static_site_generator
         @sitemap_writer = sitemap_writer
         @preprocessor = preprocessor
         @cloner_factory = cloner_factory
-        @section_repository_factory = section_repository_factory
+        @section_repository = section_repository
         @directory_preparer = directory_preparer
       end
 
@@ -48,101 +47,75 @@ module Bookbinder
       end
 
       def run(cli_arguments)
-        bind_options = BindComponents::BindOptions.new(cli_arguments, base_streams)
-        bind_options.validate!
-
-        bind_source, *options = cli_arguments
-        bind_config = config_factory.produce(bind_source)
-
-        local_repo_dir = generate_local_repo_dir(context_dir, bind_source)
-        cloner = cloner_factory.produce(local_repo_dir)
-        section_repository = section_repository_factory.produce(cloner)
+        bind_options        = BindComponents::BindOptions.new(cli_arguments, base_streams).tap(&:validate!)
+        bind_config         = config_fetcher.fetch_config
+        cloner              = cloner_factory.produce(bind_options.local_repo_dir)
 
         directory_preparer.prepare_directories(
           bind_config,
           File.expand_path('../../../../', __FILE__),
           output_locations,
-          layout_repo_path(bind_config, cloner)
+          cloner
         )
-
         sections = section_repository.fetch(
           configured_sections: bind_config.sections,
           destination_dir: output_locations.cloned_preprocessing_dir,
-          ref_override: bind_options.ref_override
+          ref_override: bind_options.ref_override,
+          cloner: cloner,
+          streams: base_streams
         )
-
         preprocessor.preprocess(
           sections,
           output_locations,
-          options: options,
+          options: bind_options.options,
           output_streams: bind_options.streams
         )
-
-        success = publish(
-          sections.map(&:subnav).reduce({}, :merge),
-          {verbose: options.include?('--verbose')},
-          bind_options.streams,
-          output_locations,
-          archive_menu_config.generate(bind_config, sections),
-          cloner
+        if file_system_accessor.file_exist?('redirects.rb')
+          file_system_accessor.copy('redirects.rb', output_locations.final_app_dir)
+        end
+        generation_result = static_site_generator.run(
+          ["build", bind_options.verbosity].compact.join(" "),
+          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)
         )
+        if generation_result.success?
+          file_system_accessor.copy(output_locations.build_dir, output_locations.public_dir)
+          result = sitemap_writer.write(
+            bind_config.public_host,
+            bind_options.streams,
+            bind_config.broken_link_exclusions
+          )
 
-        success ? 0 : 1
+          bind_options.streams[:success].puts "Bookbinder bound your book into #{output_locations.final_app_dir}"
+
+          result.has_broken_links? ? 1 : 0
+        else
+          1
+        end
       end
 
       private
 
       attr_reader(
-        :archive_menu_config,
         :base_streams,
         :cloner_factory,
-        :config_factory,
-        :context_dir,
+        :config_decorator,
+        :config_fetcher,
         :directory_preparer,
         :file_system_accessor,
         :final_app_directory,
         :output_locations,
         :preprocessor,
-        :section_repository_factory,
+        :section_repository,
         :sitemap_writer,
         :static_site_generator,
       )
 
-      def publish(subnavs, cli_options, streams, output_locations, publish_config, cloner)
-        FileUtils.cp 'redirects.rb', output_locations.final_app_dir if File.exists?('redirects.rb')
-
-        host_for_sitemap = publish_config.public_host
-
-        static_site_generator.run(output_locations,
-                                  publish_config,
-                                  cloner,
-                                  cli_options[:verbose],
-                                  subnavs)
-        file_system_accessor.copy output_locations.build_dir, output_locations.public_dir
-
-        result = sitemap_writer.write(
-          host_for_sitemap,
-          streams,
-          publish_config.broken_link_exclusions
-        )
-
-        streams[:success].puts "Bookbinder bound your book into #{output_locations.final_app_dir}"
-
-        !result.has_broken_links?
-      end
-
-      def generate_local_repo_dir(context_dir, bind_source)
-        File.expand_path('..', context_dir) if bind_source == 'local'
-      end
-
-      def layout_repo_path(config, cloner)
-        if config.has_option?('layout_repo')
-          working_copy = cloner.call(source_repo_name: config.layout_repo,
-                                     destination_parent_dir: Dir.mktmpdir)
-          working_copy.path
-        else
-          File.absolute_path('master_middleman')
-        end
+      def subnavs(sections)
+        sections.map(&:subnav).reduce({}, :merge)
       end
     end
   end

data/lib/bookbinder/commands/bind/bind_options.rb

@@ -1,5 +1,4 @@
 require_relative '../../sheller'
-require_relative '../../streams/colorized_stream'
 
 module Bookbinder
   module Commands
@@ -14,35 +13,46 @@ module Bookbinder
           raise CliError::InvalidArguments unless arguments_are_valid?
         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 opts.include?('--ignore-section-refs')
+          'master' if options.include?('--ignore-section-refs')
         end
 
         def streams
           base_streams.merge(
-            out: opts.include?('--verbose') ? base_streams[:out] : Sheller::DevNull.new,
+            out: verbosity ? base_streams[:out] : Sheller::DevNull.new,
           )
         end
 
+        def verbosity
+          options.detect {|arg| arg == '--verbose'}
+        end
+
         private
 
         attr_accessor :base_streams, :opts
 
         def arguments_are_valid?
-          valid_options = %w(--verbose --ignore-section-refs --dita-flags).to_set
-          %w(local remote github).include?(bind_source) && flag_names.to_set.subset?(valid_options)
-        end
-
-        def flag_names
-          options.map {|o| o.split('=').first}
+          %w(local remote github).include?(bind_source) && flag_names.subset?(valid_options)
         end
 
-        def bind_source
-          opts.first
+        def valid_options
+          %w(--verbose --ignore-section-refs --dita-flags).to_set
         end
 
-        def options
-          opts[1..-1]
+        def flag_names
+          options.map {|o| o.split('=').first}.to_set
         end
       end
     end

data/lib/bookbinder/commands/bind/directory_preparer.rb

@@ -1,54 +1,38 @@
-require_relative '../../directory_helpers'
-require_relative '../../ingest/destination_directory'
-
 module Bookbinder
   module Commands
     module BindComponents
       class DirectoryPreparer
-        include Bookbinder::DirectoryHelperMethods
-
-        def initialize(logger, file_system_accessor, version_control_system)
-          @logger = logger
-          @file_system_accessor = file_system_accessor
-          @version_control_system = version_control_system
+        def initialize(fs)
+          @fs = fs
         end
 
-        def prepare_directories(config, gem_root, output_locations, layout_repo_dir)
-          file_system_accessor.remove_directory(output_locations.output_dir)
-          file_system_accessor.empty_directory(output_locations.final_app_dir)
+        def prepare_directories(config, gem_root, output_locations, cloner)
+          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)
-          file_system_accessor.copy_contents(layout_repo_dir, output_locations.site_generator_home)
 
-          config.versions.each do |version|
-            copy_index_file_from_version_to_master_middleman(version, output_locations.source_for_site_generator, config.book_repo_url)
-          end
+          layout_repo_path = fetch_layout_repo(config, cloner)
+          fs.copy_contents(layout_repo_path, output_locations.site_generator_home)
         end
 
         private
 
-        attr_reader :logger, :file_system_accessor, :version_control_system
-
-        def copy_index_file_from_version_to_master_middleman(version, dest_dir, url)
-          clone_dir_name = Ingest::DestinationDirectory.new(url)
-          Dir.mktmpdir(version) do |tmpdir|
-            version_control_system.clone(url,
-                                         clone_dir_name,
-                                         path: tmpdir,
-                                         checkout: version)
-            index_source_dir = Pathname(tmpdir).join(clone_dir_name, 'master_middleman', source_dir_name)
-            index_dest_dir = File.join(dest_dir, version)
-            file_system_accessor.make_directory(index_dest_dir)
+        attr_reader :fs
 
-            Dir.glob(index_source_dir.join('index.*')) do |f|
-              file_system_accessor.copy(File.expand_path(f), index_dest_dir)
-            end
-          end
+        def copy_directory_from_gem(gem_root, dir, output_dir)
+          fs.copy_contents(File.join(gem_root, dir), output_dir)
         end
 
-        def copy_directory_from_gem(gem_root, dir, output_dir)
-          file_system_accessor.copy_contents(File.join(gem_root, dir), output_dir)
+        def fetch_layout_repo(config, cloner)
+          if config.has_option?('layout_repo')
+            cloned_repo = cloner.call(source_repo_name: config.layout_repo,
+                          destination_parent_dir: Dir.mktmpdir)
+            cloned_repo.path
+          else
+            File.absolute_path('master_middleman')
+          end
         end
       end
     end