mnogootex 0.2.1 → 1.0.0

data/lib/mnogootex/job/logger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module Mnogootex
+  module Job
+    class Logger < Thread
+      def initialize(spinner:, processor:, runners:, porters:)
+        super do
+          while runners.any?(&:alive?)
+            self.class.print_status(runners: runners, spinner: spinner)
+            sleep 0.02 # 50 fps
+          end
+          self.class.print_status(runners: runners, spinner: spinner)
+          puts
+          self.class.print_outcome(runners: runners, porters: porters, processor: processor)
+        end
+      end
+
+      class << self
+        def print_status(runners:, spinner:)
+          spinners_frames = []
+          runners.each do |runner|
+            spinner_frame = spinner[runner.count_lines % spinner.size]
+            spinners_frames << colour_by_state(spinner_frame, runner)
+          end
+          print "Runners: #{spinners_frames.join}\r"
+        end
+
+        def print_outcome(runners:, porters:, processor:)
+          puts 'Outcome:'
+          porters.zip(runners).each do |porter, runner|
+            outcome_icon = runner.successful? ? '✔'.green : '✘'.red
+            puts "  #{outcome_icon} #{porter.hid}"
+            puts processor.call(runner.log_lines) unless runner.successful?
+          end
+        end
+
+        private
+
+        def colour_by_state(string, runner)
+          if runner.alive?
+            string.yellow
+          elsif runner.successful?
+            string.green
+          else
+            string.red
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mnogootex/job/porter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'tmpdir'
+
+require 'mnogootex/utils'
+
+module Mnogootex
+  module Job
+    class Porter
+      attr_reader :hid
+
+      def initialize(hid:, source_path:)
+        @source_path = Pathname.new(source_path).realpath
+        @hid = hid
+      end
+
+      def target_dir
+        @target_dir ||= Pathname.new(Dir.tmpdir).join('mnogootex', source_id, hid)
+      end
+
+      def target_path
+        @target_path ||= target_dir.join(@source_path.basename)
+      end
+
+      def clobber
+        target_dir.rmtree if target_dir.directory?
+      end
+
+      def provide
+        target_dir.mkpath
+        # NOTE: can't use Pathname.join here since it elides the dot:
+        FileUtils.cp_r File.join(@source_path.dirname, '.'), target_dir
+        target_dir.join('.mnogootex.yml').tap { |p| p.delete if p.file? }
+        target_dir.join('.mnogootex.src').make_symlink(@source_path)
+      end
+
+      private
+
+      def source_id
+        @source_id ||= Utils.short_md5(@source_path.to_s)
+      end
+    end
+  end
+end

data/lib/mnogootex/job/runner.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Mnogootex
+  module Job
+    class Runner
+      attr_reader :hid, :log_lines
+
+      def initialize(cl:, chdir:)
+        @log_lines = []
+        _, @stream, @thread = Open3.popen2e(*cl, chdir: chdir)
+        @poller = start_poller
+      end
+
+      def alive?
+        @poller.alive?
+      end
+
+      def successful?
+        @poller.value.exitstatus.zero?
+      end
+
+      def count_lines
+        return log_lines.size unless alive?
+        @ticks = [@ticks || -1, log_lines.size - 1].min + 1
+      end
+
+      private
+
+      def start_poller
+        Thread.new do
+          until (line = @stream.gets).nil?
+            log_lines << line
+          end
+          # NOTE: waits on @thread and returns its value
+          @thread.value
+        end
+      end
+    end
+  end
+end

data/lib/mnogootex/job/warden.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+require 'mnogootex/log'
+require 'mnogootex/log/processor'
+require 'mnogootex/job/porter'
+require 'mnogootex/job/runner'
+require 'mnogootex/job/logger'
+
+module Mnogootex
+  module Job
+    class Warden
+      def initialize(source:, configuration:)
+        @source = source
+        @configuration = configuration
+
+        @processor = nil
+        @porters = []
+        @runners = []
+        @logger = nil
+      end
+
+      def start
+        init_processor
+        init_porters
+        exec_porters
+        init_and_exec_runners
+        init_and_exec_logger
+        @logger.join
+      end
+
+      private
+
+      def init_porters
+        @configuration['jobs'].each do |cls|
+          @porters << Mnogootex::Job::Porter.new(
+            hid: cls,
+            source_path: @source
+          )
+        end
+      end
+
+      def exec_porters
+        @porters.each do |porter|
+          porter.clobber
+          porter.provide
+          transformer(porter.hid, porter.target_path)
+        end
+      end
+
+      def init_and_exec_runners
+        @runners = @porters.map do |porter|
+          Mnogootex::Job::Runner.new(
+            cl: commandline(porter.target_path),
+            chdir: porter.target_dir
+          )
+        end
+      end
+
+      def init_processor
+        @processor = Log::Processor.new(
+          matchers: Mnogootex::Log::DEFAULT_MATCHERS,
+          levels: Mnogootex::Log::DEFAULT_LEVELS,
+          min_level: :info,
+          colorize: true,
+          indent_width: 4
+        )
+      end
+
+      def init_and_exec_logger
+        @logger = Mnogootex::Job::Logger.new(
+          spinner: @configuration['spinner'],
+          processor: @processor.method(:run),
+          runners: @runners,
+          porters: @porters
+        )
+      end
+
+      # TODO: generalize, integrate with Runner
+      def commandline(target_pathname)
+        [
+          *@configuration['commandline'],
+          target_pathname.basename.to_s
+        ]
+      end
+
+      # TODO: generalize, integrate with Porter
+      def transformer(new_class_name, target_pathname)
+        old_code = target_pathname.read
+        new_code = old_code.sub(
+          /\\documentclass(\[.*?\])?{.*?}/,
+          "\\documentclass{#{new_class_name}}"
+        )
+        target_pathname.write(new_code)
+      end
+    end
+  end
+end

data/lib/mnogootex/log/level.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mnogootex
+  module Log
+    # This data structure represents a log level usually referred to
+    # by its {name}. It has a numeric {priority} and a {color} used
+    # for rendering.
+    #
+    # @!attribute priority
+    #   @return [Numeric] the numeric priority of the log level
+    # @!attribute name
+    #   @return [Symbol] the human readable name of the log level
+    # @!attribute color
+    #   @return [Symbol] the color visually representing the {priority}
+    Level = Struct.new(:priority, :name, :color)
+  end
+end

data/lib/mnogootex/log/levels.yml

@@ -0,0 +1,29 @@
+- !ruby/struct:Mnogootex::Log::Level
+  priority: -.inf
+  name: !ruby/symbol all
+  # NOTE: merely symbolic, not to be used in matchers
+
+- !ruby/struct:Mnogootex::Log::Level
+  priority: 0
+  name: !ruby/symbol trace
+  color: !ruby/symbol white
+
+- !ruby/struct:Mnogootex::Log::Level
+  priority: 1
+  name: !ruby/symbol info
+  color: !ruby/symbol light_white
+
+- !ruby/struct:Mnogootex::Log::Level
+  priority: 2
+  name: !ruby/symbol warning
+  color: !ruby/symbol light_yellow
+
+- !ruby/struct:Mnogootex::Log::Level
+  priority: 3
+  name: !ruby/symbol error
+  color: !ruby/symbol light_red
+
+- !ruby/struct:Mnogootex::Log::Level
+  priority: .inf
+  name: !ruby/symbol off
+  # NOTE: merely symbolic, not to be used in matchers

data/lib/mnogootex/log/line.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mnogootex
+  module Log
+    # This data structure represents a log line.
+    # It can have a log {level} along with its {text}.
+    #
+    # @!attribute text
+    #   @return [String] the contents of the line
+    # @!attribute level
+    #   @return [Symbol] the associated log level
+    Line = Struct.new(:text, :level)
+  end
+end

data/lib/mnogootex/log/matcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mnogootex
+  module Log
+    # This data structure represents a typology of log line chunks
+    # belonging to a given log {level}.
+    # They start with a line matching {regexp} and have a fixed {length}.
+    #
+    # @!attribute regexp
+    #   @return [Regexp] the regexp to match the first line
+    # @!attribute level
+    #   @return [Symbol] the associated log level
+    # @!attribute length
+    #   @return [Integer] the number of matched lines
+    Matcher = Struct.new(:regexp, :level, :length)
+  end
+end

data/lib/mnogootex/log/matchers.yml

@@ -0,0 +1,205 @@
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/LaTeX Warning: You have requested package/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/LaTeX Font Warning: Some font shapes/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/LaTeX Font Warning: Size substitutions/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/Package caption Warning: Unsupported document class/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/Package fixltx2e Warning: fixltx2e is not required/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/Package frenchb?\.ldf Warning: (Figures|The definition)/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/\*\*\* Reloading Xunicode for encoding/' # spurious ***
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/This is `?(epsf\.tex|.*\.sty|TAP)/' # so what
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/pdfTeX warning:.*inclusion: fou/'
+  level: !ruby/symbol trace
+  length: 1
+  sample: |
+    pdfTeX warning: pdflatex.exe (file ./fig.pdf): PDF inclusion: found PDF version <1.6>, but at most version <1.5> allowed
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/pdfTeX warning:.*inclusion: mul/'
+  level: !ruby/symbol trace
+  length: 1
+  sample: |
+    pdfTeX warning: pdflatex (file ./doc.pdf): PDF inclusion: multiple pdfs with page group included in a single page
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/libpng warning: iCCP: Not recognizing/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/! $/'
+  level: !ruby/symbol trace
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/This is/'
+  level: !ruby/symbol info
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/Output written/'
+  level: !ruby/symbol info
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/No pages of output/'
+  level: !ruby/symbol info
+  length: 1
+
+# TODO: better classification below this point
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/\(.*end occurred inside a group/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/\\endL.*problem/' # XeTeX?
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/\*\*\*\s/' # *** from some packages or subprograms
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/all text was ignored after line/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/.*for symbol.*on input line/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^.*?:[0-9]+:/' # usual file:lineno: form
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/l\.[0-9]+/' # line number marking
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/(LaTeX|Package|Class).*Warning/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/(Und|Ov)erfull/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/.*Citation.*undefined/'
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/Missing character:/' # good to show (need \tracinglostchars=1)
+  level: !ruby/symbol warning
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/.*Fatal error/'
+  level: !ruby/symbol error
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/.* Error/' # as in \Url Error ->...
+  level: !ruby/symbol error
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/(LaTeX|Package|Class).*Error/'
+  level: !ruby/symbol error
+  length: 1
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^> [^<]/' # from \show..., but not "> <img.whatever"
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^.*pdfTeX warning/' # pdftex complaints often cross lines
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^LaTeX Font Warning: Font shape/'
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^Package hyperref Warning: Token not allowed/'
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^removed on input line/' # hyperref
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^Runaway argument/'
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp "/^! Undefined control sequence./"
+  level: !ruby/symbol error
+  length: 3
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp "/^! Too many }'s./"
+  level: !ruby/symbol error
+  length: 3
+  sample: |
+    ! Too many }'s.
+    l.7 ...d foo bar baz qux zod foo bar baz qux zod }
+                                                        foo
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  regexp: !ruby/regexp '/^!/' # usual ! form
+  level: !ruby/symbol error
+  length: 2
+
+- !ruby/struct:Mnogootex::Log::Matcher
+  # NOTE: do not remove, this is a catch-all filter to mark untagged lines as :trace
+  regexp: !ruby/regexp '/.*/'
+  level: !ruby/symbol trace
+  length: 1

data/lib/mnogootex/log/processor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'mnogootex/log'
+require 'mnogootex/log/line'
+
+require 'colorize'
+
+module Mnogootex
+  module Log
+    # This class exposes methods to
+    # {Processor.strings_to_lines! convert} strings into {Line}s that can be
+    # {Processor.tag_lines! tagged},
+    # {Processor.filter_lines! filtered},
+    # {Processor.colorize_lines! colored} (using {Level}s and {Matcher}s to define how)
+    # and finally
+    # {Processor.render_lines! rendered} into printable content.
+    #
+    # It can also be {Processor.initialize instantiated} with a specific configuration
+    # to {#run} the whole process repeatably on multiple inputs.
+    class Processor
+      # Converts strings into {Line}s.
+      #
+      # @param strings [Array<String>]
+      # @return [Array<Line>]
+      def self.strings_to_lines!(strings)
+        strings.map! do |line|
+          Line.new line.chomp
+        end
+      end
+
+      # Updates {Line#level}s of the given {Line}s using the {Matcher}s.
+      #
+      # @param lines [Array<Line>]
+      # @param matchers [Array<Matcher>]
+      # @return [Array<Line>]
+      def self.tag_lines!(lines, matchers:)
+        tail_length, matcher = 0 # , nil
+        lines.each do |line|
+          if tail_length.zero?
+            matcher = matchers.detect { |m| m.regexp === line.text }
+            tail_length = matcher&.length&.-(1) || 0
+          else # still on the tail of the previous match
+            tail_length -= 1
+          end
+          line.level = matcher&.level
+        end
+      end
+
+      # Discards {Line}s having {Line.level}s with {Level#priority}
+      # lower than the minimum, according the {Level}s hash.
+      #
+      # @param lines [Array<Line>]
+      # @param levels [Hash<Symbol, Level>]
+      # @param min_level [Symbol]
+      # @return [Array<Line>]
+      def self.filter_lines!(lines, levels:, min_level:)
+        lines.select! do |line|
+          levels.fetch(line.level).priority >= levels.fetch(min_level).priority
+        end
+      end
+
+      # Applies {Level#color}s to the {Line}s, according the {Level}s hash.
+      #
+      # @param lines [Array<Line>]
+      # @param levels [Array<Level>]
+      # @return [Array<Line>]
+      def self.colorize_lines!(lines, levels:)
+        lines.each do |line|
+          line.text = line.text.colorize(levels.fetch(line.level).color)
+        end
+      end
+
+      # Renders {Line}s to space-indented strings terminated by a newline.
+      #
+      # @param lines [Array<Line>]
+      # @param indent_width [Fixnum]
+      # @return [Array<String>]
+      def self.render_lines!(lines, indent_width:)
+        lines.map! { |line| "#{' ' * indent_width}#{line.text}\n" }
+      end
+
+      # @param matchers [Array<Matcher>]
+      # @param levels [Array<Level>]
+      # @param indent_width [Fixnum]
+      # @param min_level [Symbol]
+      def initialize(matchers:, levels:, min_level:, colorize:, indent_width:)
+        @matchers = matchers
+        @levels = levels
+        @min_level = min_level
+        @colorize = colorize
+        @indent_width = indent_width
+      end
+
+      # Runs the {Processor Processor} on the given strings to
+      # {Processor.strings_to_lines! convert},
+      # {Processor.tag_lines! tag},
+      # {Processor.filter_lines! filter},
+      # {Processor.colorize_lines! color} and
+      # {Processor.render_lines! render} them
+      # using its {Processor.initialize initialization} parameters.
+      #
+      # @param lines [Array<String>]
+      # @return [Array<String>]
+      def run(lines)
+        @lines = lines.dup
+        Processor.strings_to_lines! @lines
+        Processor.tag_lines! @lines, matchers: @matchers
+        Processor.filter_lines! @lines, levels: @levels, min_level: @min_level
+        Processor.colorize_lines! @lines, levels: @levels if @colorize
+        Processor.render_lines! @lines, indent_width: @indent_width
+        @lines
+      end
+    end
+  end
+end

data/lib/mnogootex/log.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'mnogootex/log/level'
+require 'mnogootex/log/matcher'
+
+require 'pathname'
+require 'yaml'
+
+module Mnogootex
+  # {Log} implements means to reduce log floods into filtered, color coded and human friendly summaries.
+  #
+  # * {Line}s are log lines.
+  # * {Level}s define log levels, their priority and color coding.
+  # * {Matcher}s define patterns to determine the level of log lines.
+  # * {Processor}s implement all transformations.
+  #
+  module Log
+    DEFAULT_LEVELS_PATH = Pathname.new(__dir__).join('log', 'levels.yml')
+    DEFAULT_MATCHERS_PATH = Pathname.new(__dir__).join('log', 'matchers.yml')
+    DEFAULT_LEVELS = YAML.load_file(DEFAULT_LEVELS_PATH).map { |l| [l.name, l] }.to_h.freeze
+    DEFAULT_MATCHERS = YAML.load_file(DEFAULT_MATCHERS_PATH).freeze
+  end
+end

data/lib/mnogootex/mnogoo.sh

@@ -0,0 +1,21 @@
+# Usage: source this in your bash profile as
+# [ -s "$(mnogootex mnogoo)" ] && . "$(mnogootex mnogoo)"
+
+mnogoo () {
+    if [ "$1" = cd ]; then
+        MN_PATH="$(IS_MNOGOO=true mnogootex dir "${@:2}")" || return
+        cd "$MN_PATH" || exit
+    elif [ "$1" = open ]; then
+        MN_PATH="$(IS_MNOGOO=true mnogootex pdf "${@:2}")" || return
+        if command -v open >/dev/null 2>&1; then
+            printf '%s\n' "$MN_PATH" | while read -r line; do open "$line"; done
+        elif command -v xdg-open >/dev/null 2>&1; then
+            printf '%s\n' "$MN_PATH" | while read -r line; do xdg-open "$line"; done
+        else
+            echo "No known file opener (open, xdg-open) found on your system."
+            echo "Please do chime in with suggestions: <paolo.brasolin@gmail.com>"
+        fi
+    else
+        IS_MNOGOO=true mnogootex "$@"
+    fi
+}