giblish 0.7.6 → 0.8.0

data/lib/giblish/docconverter.rb

@@ -5,22 +5,21 @@ require "asciidoctor-pdf"
 require_relative "utils"
 
 module Giblish
-
   # Base class for document converters. It contains a hash of
   # conversion options used by derived classes
   class DocConverter
     # a common set of converter options used for all output formats
     COMMON_CONVERTER_OPTS = {
-        safe: Asciidoctor::SafeMode::UNSAFE,
-        header_footer: true,
-        mkdirs: true
+      safe: Asciidoctor::SafeMode::UNSAFE,
+      header_footer: true,
+      mkdirs: true
     }.freeze
 
     # the giblish attribute defaults used if nothing else
     # is required by the user
     DEFAULT_ATTRIBUTES = {
-        "source-highlighter" => "rouge",
-        "xrefstyle" => "short"
+      "source-highlighter" => "rouge",
+      "xrefstyle" => "short"
     }.freeze
 
     # setup common options that are used regardless of the
@@ -54,27 +53,26 @@ module Giblish
     #
     # Returns: The resulting Asciidoctor::Document object
     def convert(filepath, logger: nil)
-      unless filepath.is_a?(Pathname)
-        raise ArgumentError, "Trying to invoke convert with non-pathname!"
-      end
+      raise ArgumentError, "Trying to invoke convert with non-pathname!" unless filepath.is_a?(Pathname)
 
-      Giblog.logger.info {"Processing: #{filepath}"}
+      Giblog.logger.info { "Processing: #{filepath}" }
 
       # update the relevant options for each specific document
-      set_common_doc_specific_options(filepath,logger)
+      set_common_doc_specific_options(filepath, logger)
 
       # give derived classes the opportunity to set doc specific attributes
-      add_doc_specific_attributes(filepath,true, @converter_options[:attributes])
+      add_doc_specific_attributes(filepath, true, @converter_options[:attributes])
 
-      Giblog.logger.debug {"converter_options: #{@converter_options}"}
+      Giblog.logger.debug { "converter_options: #{@converter_options}" }
 
       # do the actual conversion
       doc = Asciidoctor.convert_file filepath, @converter_options
 
       # bail out if asciidoctor failed to convert the doc
-      if logger && logger.max_severity && logger.max_severity > Logger::Severity::WARN
-        raise RuntimeError, "Failed to convert the file #{filepath}"
+      if logger&.max_severity && logger.max_severity > Logger::Severity::WARN
+        raise "Failed to convert the file #{filepath}"
       end
+
       doc
     end
 
@@ -86,8 +84,7 @@ module Giblish
     # to disk.
     # Returns: whether any errors occured during conversion (true) or
     # not (false).
-    def convert_str(src_str, dst_dir, basename,logger: nil)
-
+    def convert_str(src_str, dst_dir, basename, logger: nil)
       index_opts = @converter_options.dup
 
       # use the same options as when converting all docs
@@ -96,15 +93,13 @@ module Giblish
       # necessary to change
       index_opts[:to_dir] = dst_dir.to_s
       index_opts[:base_dir] = dst_dir.to_s
-      index_opts.delete_if {|k, _v| %i[to_file].include? k}
+      index_opts.delete_if { |k, _v| %i[to_file].include? k }
 
       # give derived classes the opportunity to set doc specific attributes
       index_filepath = dst_dir + "#{basename}.#{index_opts[:fileext]}"
-      add_doc_specific_attributes(index_filepath,false, index_opts[:attributes])
+      add_doc_specific_attributes(index_filepath, false, index_opts[:attributes])
 
       # load and convert the document using the converter options
-      doc = nil, output = nil
-
       begin
         conv_error = false
         # set a specific logger instance to-be-used by asciidoctor
@@ -112,14 +107,16 @@ module Giblish
         doc = Asciidoctor.load src_str, index_opts
         output = doc.convert index_opts
 
-        if logger && logger.max_severity && logger.max_severity > Logger::Severity::WARN
-          raise RuntimeError, "Failed to convert string to asciidoc!! Will _not_ generate #{index_filepath.to_s}"
+        if logger&.max_severity && logger.max_severity > Logger::Severity::WARN
+          raise "Failed to convert string to asciidoc!! "\
+                "Will _not_ generate #{index_filepath}"
         end
 
         # write the converted document to an index file located at the
         # destination root
         doc.write output, index_filepath.to_s
-      rescue Exception => e
+      rescue StandardError => e
+        puts e.backtrace
         Giblog.logger.error(e)
         conv_error = true
       end
@@ -148,21 +145,19 @@ module Giblish
 
     # Hook for specific converters to inject attributes on a per-doc
     # basis
-    def add_doc_specific_attributes(filepath, is_src, attributes)
-
-    end
+    def add_doc_specific_attributes(filepath, is_src, attributes); end
 
     private
 
-    def set_common_doc_specific_options(src_filepath,logger)
+    def set_common_doc_specific_options(src_filepath, logger)
       # create an asciidoc doc object and convert to requested
       # output using current conversion options
       @converter_options[:to_dir] = @paths.adoc_output_dir(src_filepath).to_s
       @converter_options[:base_dir] =
-          Giblish::PathManager.closest_dir(src_filepath).to_s
+        Giblish::PathManager.closest_dir(src_filepath).to_s
       @converter_options[:to_file] =
-          Giblish::PathManager.get_new_basename(src_filepath,
-                                                @converter_options[:fileext])
+        Giblish::PathManager.get_new_basename(src_filepath,
+                                              @converter_options[:fileext])
       @converter_options[:logger] = logger unless logger.nil?
     end
   end
@@ -178,9 +173,9 @@ module Giblish
       validate_and_copy_resources @dst_asset_dir
 
       # identify ourselves as an html converter
-      add_backend_options({backend: "html5", fileext: "html"})
+      add_backend_options({ backend: "html5", fileext: "html" })
       # setup the attributes specific for this converter
-      add_backend_attributes(get_common_attributes)
+      add_backend_attributes(common_attributes)
     end
 
     protected
@@ -190,11 +185,11 @@ module Giblish
       if @paths.resource_dir_abs
         # user has given a resource dir, use the css from that dir
         doc_attrib.merge!(
-            {
-                "linkcss" => 1,
-                "stylesheet" => @user_style ||= "giblish.css",
-                "copycss!" => 1
-            }
+          {
+            "linkcss" => 1,
+            "stylesheet" => @user_style ||= "giblish.css",
+            "copycss!" => 1
+          }
         )
         if @deployment_info.web_path.nil?
           # user wants to deploy without web server, the css
@@ -204,8 +199,8 @@ module Giblish
           css_rel_dir = if is_src_file
                           # the filepath is a src path
                           @paths.relpath_to_dir_after_generate(
-                              filepath,
-                              dst_css_dir
+                            filepath,
+                            dst_css_dir
                           )
                         else
                           # the given file path is the destination path of
@@ -221,21 +216,20 @@ module Giblish
           doc_attrib["stylesdir"] = @deployment_info.web_path.join("css").cleanpath.to_s
         end
       end
-        Giblog.logger.debug {"Rendered docs expect a css at: #{doc_attrib["stylesdir"]}"}
-        Giblog.logger.debug {"The expected css is named: #{doc_attrib["stylesheet"]}"}
+      Giblog.logger.debug { "Rendered docs expect a css at: #{doc_attrib['stylesdir']}" }
+      Giblog.logger.debug { "The expected css is named: #{doc_attrib['stylesheet']}" }
 
       attributes.merge!(doc_attrib)
     end
 
     private
 
-    def get_common_attributes
+    def common_attributes
       # Setting 'data-uri' makes asciidoctor embed images in the resulting
       # html file
-      html_attrib = {
-          "data-uri" => 1,
+      {
+        "data-uri" => 1
       }
-      html_attrib
     end
 
     def copy_resource_dir(dst_dir)
@@ -263,46 +257,50 @@ module Giblish
       if @user_style
         # Make sure that a user supplied stylesheet ends with .css or .CSS
         @user_style && @user_style =
-            /\.(css|CSS)$/ =~ @user_style ? @user_style : "#{@user_style}.css"
+                         /\.(css|CSS)$/ =~ @user_style ? @user_style : "#{@user_style}.css"
 
         # bail out if we can not find the given css file
-        src_css_path = @paths.resource_dir_abs.
-            join("css").join(Pathname.new(@user_style))
-        raise RuntimeError, "Could not find the specified " +
-            "css file at: #{src_css_path}" unless src_css_path.exist?
+        src_css_path = @paths.resource_dir_abs
+                             .join("css").join(Pathname.new(@user_style))
+        unless src_css_path.exist?
+          raise "Could not find the specified "\
+                "css file at: #{src_css_path}"
+        end
       end
 
       copy_resource_dir dst_dir
     end
   end
 
+  # Converts adoc into pdf
   class PdfConverter < DocConverter
     def initialize(paths, deployment_info, options)
       super paths, deployment_info, options
+      require "asciidoctor-mathematical"
 
       # identify ourselves as a pdf converter
-      add_backend_options({backend: "pdf", fileext: "pdf"})
+      add_backend_options({ backend: "pdf", fileext: "pdf" })
       # setup the attributes specific for this converter
       add_backend_attributes(setup_pdf_attribs)
     end
 
     private
 
-    def setup_pdf_attribs()
+    def setup_pdf_attribs
       # only set this up if user has specified a resource dir
       return {} unless @paths.resource_dir_abs
 
       pdf_attrib = {
-          "pdf-stylesdir" => "#{@paths.resource_dir_abs}/themes",
-          "pdf-style" => "giblish.yml",
-          "pdf-fontsdir" => "#{@paths.resource_dir_abs}/fonts",
-          "icons" => "font"
+        "pdf-stylesdir" => "#{@paths.resource_dir_abs}/themes",
+        "pdf-style" => "giblish.yml",
+        "pdf-fontsdir" => "#{@paths.resource_dir_abs}/fonts",
+        "icons" => "font"
       }
 
       # Make sure that the stylesheet ends with .yml or YML
       @user_style &&
-          pdf_attrib["pdf-style"] =
-              /\.(yml|YML)$/ =~ @user_style ? @user_style : "#{@user_style}.yml"
+        pdf_attrib["pdf-style"] =
+          /\.(yml|YML)$/ =~ @user_style ? @user_style : "#{@user_style}.yml"
 
       pdf_attrib
     end

data/lib/giblish/docid.rb

@@ -1,8 +1,8 @@
-
 require_relative "./utils"
 require "asciidoctor"
 require "asciidoctor/extensions"
 
+# put docid stuff in the giblish namespace
 module Giblish
   # Parse all adoc files for :docid: attributes
   class DocidCollector < Asciidoctor::Extensions::Preprocessor
@@ -15,13 +15,7 @@ module Giblish
     @docid_deps = {}
 
     class << self
-      def docid_cache
-        @docid_cache
-      end
-
-      def docid_deps
-        @docid_deps
-      end
+      attr_reader :docid_cache, :docid_deps
 
       def clear_cache
         @docid_cache = {}
@@ -64,6 +58,7 @@ module Giblish
     # add a new source document to the docid_deps
     def add_source_dep(src_path)
       return if docid_deps.key? src_path
+
       docid_deps[src_path] = []
     end
 
@@ -123,9 +118,7 @@ module Giblish
     # Get the relative path from the src doc to the
     # doc with the given doc id
     def get_rel_path(src_path, doc_id)
-      unless docid_cache.key? doc_id
-        raise ArgumentError("unknown doc id: #{doc_id}")
-      end
+      raise ArgumentError("unknown doc id: #{doc_id}") unless docid_cache.key? doc_id
 
       rel_path = docid_cache[doc_id]
                  .dirname
@@ -176,7 +169,6 @@ module Giblish
     end
   end
 
-
   # Helper method to register the docid preprocessor extension with
   # the asciidoctor engine.
   def register_docid_extension

data/lib/giblish/docinfo.rb

@@ -4,52 +4,26 @@ module Giblish
   # Container class for bundling together the data we cache for
   # each asciidoc file we come across
   class DocInfo
-    # Cache git info
+    # History info from git
     class DocHistory
-      attr_accessor :date
-      attr_accessor :author
-      attr_accessor :message
+      attr_accessor :date, :author, :message
     end
 
-    attr_accessor :converted
-    attr_accessor :doc_id
-    attr_accessor :purpose_str
-    attr_accessor :status
-    attr_accessor :history
-    attr_accessor :error_msg
-    attr_accessor :stderr
+    attr_accessor :converted, :doc_id, :purpose_str, :status, :history, :error_msg, :stderr
+    attr_reader :title, :rel_path, :src_file
 
     # these members can have encoding issues when
     # running in a mixed Windows/Linux setting.
     # that is why we explicitly encodes them when
     # writing to them
-    def title
-      @title
-    end
+
     def title=(rhs)
       @title = rhs.nil? ? nil : rhs.encode("utf-8")
     end
-    def rel_path
-      @rel_path
-    end
-    # attr_accessor :rel_path
-    def src_file
-      @src_file
-    end
+
     def src_file=(rhs)
       @src_file = rhs.nil? ? nil : rhs.encode("utf-8")
     end
-    # attr_accessor :src_file
-
-    # def relPath_utf8
-    #   return nil if @rel_path.nil?
-    #   @rel_path.to_s.encode("utf-8")
-    # end
-    #
-    # def srcFile_utf8
-    #   return nil if @src_file.nil?
-    #   @src_file.to_s.encode("utf-8")
-    # end
 
     def initialize(adoc: nil, dst_root_abs: nil, adoc_stderr: "")
       @src_file = nil
@@ -63,14 +37,14 @@ module Giblish
 
       # fill in doc meta data
       d_attr = adoc.attributes
-      self.src_file=(d_attr["docfile"])
-      self.title=(adoc.doctitle)
+      self.src_file = (d_attr["docfile"])
+      self.title = (adoc.doctitle)
       @doc_id = d_attr["docid"]
       return if dst_root_abs.nil?
 
       # Get the relative path beneath the root dir to the doc
       @rel_path = Pathname.new(
-          "#{d_attr['outdir']}/#{d_attr['docname']}#{d_attr['docfilesuffix']}".encode("utf-8")
+        "#{d_attr['outdir']}/#{d_attr['docname']}#{d_attr['docfilesuffix']}".encode("utf-8")
       ).relative_path_from(dst_root_abs)
     end
 
@@ -82,19 +56,20 @@ module Giblish
 
     def get_purpose_info(adoc)
       # Get the 'Purpose' section if it exists
-      purpose_str = ""
+      purpose_str = String.new("")
       adoc.blocks.each do |section|
         next unless section.is_a?(Asciidoctor::Section) &&
-            (section.level == 1) &&
-            (section.name =~ /^Purpose$/)
+                    (section.level == 1) &&
+                    (section.name =~ /^Purpose$/)
 
         # filter out 'odd' text, such as lists etc...
         section.blocks.each do |bb|
           next unless bb.is_a?(Asciidoctor::Block)
+
           purpose_str << "#{bb.source}\n+\n"
         end
       end
       purpose_str
     end
   end
-end
+end

data/lib/giblish/gititf.rb

@@ -5,15 +5,13 @@ module Giblish
   # A home-grown interface class to git. Used for situations when the
   # 'official' ruby git gem does not support an operation that is needed.
   class GitItf
-    attr_reader :repo_root
-    attr_reader :git_dir
+    attr_reader :repo_root, :git_dir
 
     def initialize(path)
       @repo_root = Giblish::PathManager.find_gitrepo_root(path)
-      if @repo_root.nil?
-        raise ArgumentError("The path: @{path} is not within a git repo!")
-      end
-      @git_dir = @repo_root + ".git"
+      raise ArgumentError("The path: @{path} is not within a git repo!") if @repo_root.nil?
+
+      @git_dir = @repo_root / ".git"
     end
 
     # Get the log history of the supplied file as an array of

data/lib/giblish/indexheadings.rb

@@ -4,8 +4,8 @@ require "asciidoctor"
 require "asciidoctor/extensions"
 require_relative "./utils"
 
+# put the indexing in the giblish namespace
 module Giblish
-
   # This hook is called by Asciidoctor once for each document _before_
   # Asciidoctor processes the adoc content.
   #
@@ -36,29 +36,26 @@ module Giblish
   #   }]
   # }
   class IndexHeadings < Asciidoctor::Extensions::Preprocessor
-
     # Use a class-global heading_index dict since asciidoctor creates a new instance
     # of this class for each processed file
-    @heading_index = {"file_infos" => []}
+    @heading_index = { "file_infos" => [] }
 
     # prio order:
     # 1. values in this hash
     # 2. values taken from the document
     # 3. default values
     @id_elements = {
-#        prefix: "_",
-#        separator: "_"
+      #        prefix: "_",
+      #        separator: "_"
     }
 
     class << self
       attr_accessor :id_elements
 
-      def heading_index
-        @heading_index
-      end
+      attr_reader :heading_index
 
       def clear_index
-        @heading_index = {"file_infos" => []}
+        @heading_index = { "file_infos" => [] }
       end
 
       # write the index to a file in dst_dir and remove the base_dir
@@ -73,11 +70,11 @@ module Giblish
           # remove the base_dir part of the file path
           heading_index["file_infos"].each do |file_info|
             file_info["filepath"] = Pathname.new(file_info["filepath"])
-                                        .relative_path_from(base_dir)
+                                            .relative_path_from(base_dir)
           end
         end
 
-        Giblog.logger.info { "writing json to #{dst_dir.join("heading_index.json").to_s}" }
+        Giblog.logger.info { "writing json to #{dst_dir.join('heading_index.json')}" }
         File.open(dst_dir.join("heading_index.json").to_s, "w") do |f|
           f.write(heading_index.to_json)
         end
@@ -100,15 +97,15 @@ module Giblish
 
       # make sure we use the correct id elements when indexing
       # sections
-      opts = set_id_attributes(reader.lines)
+      opts = find_id_attributes(reader.lines)
 
       # Index all headings in the doc
       Giblog.logger.debug { "indexing headings in #{src_path}" }
       sections = []
       file_info_hash = {
-          "filepath" => src_path,
-          "title" => title,
-          "sections" => sections
+        "filepath" => src_path,
+        "title" => title,
+        "sections" => sections
       }
 
       index_sections(reader, file_info_hash, opts)
@@ -152,17 +149,21 @@ module Giblish
           m = heading_regex.match(line)
           if m
             # we have an anchor and got a heading as expected, index it
-            section = {"id" => match_str}
+            section = { "id" => match_str }
             section["title"] = m[1].strip
             section["line_no"] = line_no
             sections << section
           else
-            Giblog.logger.debug { "Did not index the anchor: #{match_str} at line #{line_no}, probably not associated with a heading." }
+            Giblog.logger.debug do
+              "Did not index the anchor: #{match_str} at "\
+              "line #{line_no}, probably not associated "\
+              "with a heading."
+            end
           end
           state = :text
         when :heading
           # we got a heading without an accompanying anchor, index it
-          section = {"id" => get_unique_id(file_info_hash, match_str, opts)}
+          section = { "id" => get_unique_id(file_info_hash, match_str, opts) }
           section["title"] = m[1].strip
           section["line_no"] = line_no
           sections << section
@@ -187,43 +188,38 @@ module Giblish
     # 1. values in class variable
     # 2. values taken from doc
     # 3. default values
-    def set_id_attributes(lines)
-      # default values
-      result = {
-          id_prefix: "_",
-          id_separator: "_"
-      }
-
+    def find_id_attributes(lines)
+      result = {}
+      # prio 1
+      result[:id_prefix] = IndexHeadings.id_elements.fetch(:id_prefix, nil)
+      result[:id_separator] = IndexHeadings.id_elements.fetch(:id_separator, nil)
+      return result if result[:id_prefix] && result[:id_separator]
+
+      # prio 2
       # check if the doc specifies id attributes
       Giblish.process_header_lines(lines) do |line|
         m = /^:idprefix:(.*)$/.match(line)
         n = /^:idseparator:(.*)$/.match(line)
-        if m
+        if m && !result[:id_prefix]
           # We found a id prefix
           result[:id_prefix] = m[1].strip
         end
-        if n
+        if n && !result[:id_separator]
           # We found a id separator
           result[:id_separator] = n[1].strip
         end
       end
 
-
-      if IndexHeadings.id_elements.has_key?(:id_prefix)
-        result[:id_prefix] = IndexHeadings.id_elements[:id_prefix]
-      end
-
-      if IndexHeadings.id_elements.has_key?(:id_separator)
-        result[:id_separator] = IndexHeadings.id_elements[:id_separator]
-      end
-
+      # prio 3
+      # default values
+      result[:id_prefix] = "_" unless result[:id_prefix]
+      result[:id_separator] = "_" unless result[:id_separator]
       result
     end
 
     def get_unique_id(doc_heading_dict, heading_str, opts)
-
       id_base = Giblish.to_valid_id(heading_str, opts[:id_prefix], opts[:id_separator])
-      return id_base if !doc_heading_dict.key? id_base
+      return id_base unless doc_heading_dict.key? id_base
 
       # handle the case with several sections with the same name
       idx = 1
@@ -234,7 +230,7 @@ module Giblish
         # some code here
         break unless doc_heading_dict.key? heading_id
       end
-      return heading_id
+      heading_id
     end
 
     # Helper method to shorten calls to the heading_index from instance methods