mnogootex 0.2.1 → 1.0.0

data/lib/mnogootex/utils.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Mnogootex
+  module Utils
+    def self.short_md5(input)
+      [Digest::MD5.digest(input)]. # get 16 bytes of MD5
+        pack('m0'). # pack them into 22+2 base64 bytes (w/o trailing newline)
+        tr('+/', '-_'). # make then url/path-safe
+        chomp('==') # drop last 2 padding bytes
+    end
+
+    def self.humanize_bytes(size)
+      %w[b Kb Mb Gb Tb Pb Eb Zb Yb].reduce(size) do |magnitude, unit|
+        break "#{magnitude}#{unit}" if magnitude < 1024
+        magnitude / 1024
+      end
+    end
+
+    def self.dir_size(mask)
+      Dir.glob(Pathname.new(mask).join('**', '*')).
+        map! { |f| Pathname.new(f).size }.inject(:+) || 0
+    end
+  end
+end

data/lib/mnogootex/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mnogootex
-  VERSION = "0.2.1"
+  VERSION = '1.0.0'
 end

data/lib/mnogootex.rb

@@ -1,7 +1,7 @@
-require "mnogootex/version"
-require "mnogootex/configuration"
-require "mnogootex/job"
+# frozen_string_literal: true
+
+require 'mnogootex/version'
+require 'mnogootex/cli'
 
 module Mnogootex
-  # Your code goes here...
 end

data/mnogootex.gemspec

@@ -1,30 +1,53 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "mnogootex/version"
+require 'mnogootex/version'
 
-Gem::Specification.new do |spec|
-  spec.name          = "mnogootex"
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+  spec.name          = 'mnogootex'
   spec.version       = Mnogootex::VERSION
-  spec.authors       = ["Paolo Brasolin"]
-  spec.email         = ["paolo.brasolin@gmail.com"]
+  spec.authors       = ['Paolo Brasolin']
+  spec.email         = ['paolo.brasolin@gmail.com']
 
-  spec.summary       = %q{Mnogootex (многоꙮтех) is a device to handle the compilation of TeX sources with different preambles at one time.}
-  spec.description   = %q{Mnogootex (многоꙮтех) is a device to handle the compilation of TeX sources with different preambles at one time. This avoids wasting time when you have to submit a paper to journals using outdated or crummy document classes.}
-  spec.homepage      = "https://github.com/tetrapharmakon/mnogootex"
-  spec.license       = "MIT"
+  spec.summary       = <<~SUMMARY.tr("\n", ' ').squeeze(' ').strip
+    Многоꙮтех (mnogootex) is a utility that parallelizes compilation
+    of a LaTeX document using different classes and offers a
+    meaningfully filtered output.
+  SUMMARY
+
+  spec.description = <<~DESCRIPTION.tr("\n", ' ').squeeze(' ').strip
+    Многоꙮтех (mnogootex) is a utility that parallelizes compilation
+    of a LaTeX document using different classes and offers a
+    meaningfully filtered output.
+    The motivating use case is maintaining a single preamble while
+    submitting a paper to many journals using their outdated or crummy
+    document classes.
+  DESCRIPTION
+
+  spec.homepage      = 'https://github.com/tetrapharmakon/mnogootex'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features|mwe|mnogootex_classes)/})
+    f.match(%r{^(test|mwe)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'byebug', '~> 10.0'
+  spec.add_development_dependency 'dry-inflector', '~> 0.1.1'
+  spec.add_development_dependency 'guard', '~> 2.14'
+  spec.add_development_dependency 'guard-rspec', '~> 4.7'
+  spec.add_development_dependency 'mutant', '~> 0.8.14'
+  spec.add_development_dependency 'mutant-rspec', '~> 0.8.14'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'rubocop', '~> 0.52.1'
+  spec.add_development_dependency 'simplecov', '~> 0.15.1'
+  spec.add_development_dependency 'yard', '~> 0.9.12'
 
-  spec.add_dependency "colorize"
+  spec.add_dependency 'colorize', '~> 0.8.1'
+  spec.add_dependency 'thor', '~> 0.20.0'
 end

data/spec/mnogootex/cfg_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'yaml'
+require 'tmpdir'
+
+require 'mnogootex/cfg'
+
+describe Mnogootex::Cfg do
+  describe 'load_descending' do
+    context 'fake file structure' do
+      subject { described_class.load_descending(pathname: Pathname.new('foobar'), basename: 'cfg.yml') }
+
+      it 'raises an error on loading a fake path' do
+        expect { subject }.to raise_exception Errno::ENOENT
+      end
+    end
+
+    context 'real file structure' do
+      subject { described_class.load_descending(pathname: tmp_dir.join('A', 'B'), basename: 'cfg.yml') }
+      let(:defaults) { { default: true, winner: 'default' } }
+      let(:tmp_dir) { Pathname.new(Dir.mktmpdir).join('mnogootex-test') }
+
+      before do
+        tmp_dir.join('A', 'B').mkpath
+        tmp_dir.join('cfg.yml').write('') # NOTE: empty file
+        tmp_dir.join('A', 'cfg.yml').write({ parent: true, winner: 'parent', merged: { deep: true } }.to_yaml)
+        tmp_dir.join('A', 'B', 'cfg.yml').write({ child: true, winner: 'child', merged: {} }.to_yaml)
+      end
+
+      after do
+        tmp_dir.rmtree
+      end
+
+      it 'merges paths' do
+        expect(subject).to include(:parent)
+        expect(subject).to include(:child)
+      end
+
+      it 'merges shallowly' do
+        expect(subject[:merged]).to_not include(:deep)
+      end
+
+      it 'privileges deeper paths' do
+        expect(subject[:winner]).to eq('child')
+      end
+
+      it 'privileges non defaults' do
+        expect(subject[:winner]).to_not eq('default')
+      end
+    end
+  end
+end

data/spec/mnogootex/job/porter_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mnogootex/job/porter'
+
+require 'mnogootex/utils'
+
+describe Mnogootex::Job::Porter do
+  # NOTE: using mktmpdir instead of tmpdir allows parallelization
+  let(:test_dir) { Pathname.new(Dir.mktmpdir).join('mnogootex-test') }
+  before { test_dir.mkpath }
+  after { test_dir.rmtree }
+
+  describe '.new' do
+    it 'requires a source' do
+      expect { described_class.new hid: '1', source_path: nil }.to raise_exception(TypeError)
+    end
+
+    it 'requires source to exist' do
+      expect { described_class.new hid: '1', source_path: 'foobar' }.to raise_exception(Errno::ENOENT)
+    end
+
+    it 'accepts string as source' do
+      expect { described_class.new hid: '1', source_path: test_dir.to_s }.to_not raise_exception
+    end
+
+    it 'accepts pathname as source' do
+      expect { described_class.new hid: '1', source_path: test_dir }.to_not raise_exception
+    end
+  end
+
+  describe '#target_dir' do
+    before do
+      test_dir.join('a').mkpath
+      test_dir.join('b').mkpath
+      test_dir.join('a', 'main.file').write('')
+      test_dir.join('b', 'main.file').write('')
+    end
+    let(:porter_a1) { described_class.new hid: '1', source_path: test_dir.join('a', 'main.file') }
+    let(:porter_a2) { described_class.new hid: '2', source_path: test_dir.join('a', 'main.file') }
+    let(:porter_b1) { described_class.new hid: '1', source_path: test_dir.join('b', 'main.file') }
+
+    it 'has a deterministic location' do
+      hash = Mnogootex::Utils.short_md5(test_dir.join('a', 'main.file').realpath.to_s)
+      expect(porter_a1.target_dir.to_s).
+        to match(%r{\A.+/mnogootex/#{hash}/#{1}\z})
+    end
+
+    it 'discriminates by hid' do
+      expect(porter_a1.target_dir).to_not eq(porter_a2.target_dir)
+    end
+
+    it 'discriminates by source' do
+      expect(porter_a1.target_dir).to_not eq(porter_b1.target_dir)
+    end
+  end
+
+  describe '#target_path' do
+    let(:source_path) { test_dir.join('a', 'main.file') }
+    let(:porter) { described_class.new hid: '1', source_path: source_path }
+
+    before do
+      source_path.dirname.mkpath
+      source_path.write('')
+    end
+
+    it 'rescopes source basename into target dirname' do
+      expect(porter.target_path.basename).to eq(source_path.basename)
+      expect(porter.target_path.dirname).to eq(porter.target_dir)
+    end
+  end
+
+  describe '#provide' do
+    let(:source_path) { test_dir.join('A', 'main.file') }
+
+    before do
+      test_dir.join('A', 'B').mkpath
+      test_dir.join('A', 'main.file').write('')
+      test_dir.join('A', '.mnogootex.yml').write('')
+      test_dir.join('A', '.dotfile').write('')
+      test_dir.join('A', 'B', 'ancillary.file').write('')
+    end
+
+    subject { described_class.new hid: 'job_id', source_path: source_path }
+
+    it 'creates target directory' do
+      subject.provide
+      expect(subject.target_dir).to be_directory
+    end
+
+    it 'ignores configuration file' do
+      test_dir.join('A', '.mnogootex.yml').unlink
+      subject.provide
+      expect(subject.target_dir.join('.mnogootex.yml')).to_not exist
+    end
+
+    it 'creates link to source' do
+      subject.provide
+      expect(subject.target_dir.join('.mnogootex.src').readlink).to eq(source_path.realpath)
+    end
+
+    def relative_subtree(pathname)
+      Pathname.glob(pathname.join('**', '{.*,*}')).map do |child|
+        child.relative_path_from(pathname)
+      end
+    end
+
+    it 'copies all source files' do
+      subject.provide
+      subject.target_dir.join('.mnogootex.src').unlink
+      source_path.dirname.join('.mnogootex.yml').unlink
+      # NOTE: unlinking so comparison is easier to write
+      expect(relative_subtree(source_path.dirname)).
+        to eq(relative_subtree(subject.target_dir))
+    end
+  end
+
+  describe '#clobber' do
+    let(:source_path) { test_dir.join('A', 'main.file') }
+
+    before do
+      test_dir.join('A', 'B').mkpath
+      test_dir.join('A', 'main.file').write('')
+    end
+
+    subject { described_class.new hid: 'job_id', source_path: source_path }
+
+    it 'cleans up target dir if it exists' do
+      subject.provide
+      expect(subject.target_dir).to exist
+      subject.clobber
+      expect(subject.target_dir).to_not exist
+    end
+
+    it 'does nothing if target dir does not exist' do
+      expect(subject.target_dir).to_not exist
+      expect { subject.clobber }.to_not raise_exception
+    end
+  end
+end

data/spec/mnogootex/job/runner_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mnogootex/job/runner'
+
+require 'tmpdir'
+
+describe Mnogootex::Job::Runner do
+  let(:test_dir) { Pathname.new(Dir.mktmpdir) }
+  before { test_dir.mkpath }
+  after { test_dir.rmtree }
+
+  it 'executes commandline in given dir' do
+    runner = described_class.new(cl: 'pwd', chdir: test_dir)
+    expect(runner).to be_successful
+    expect(runner.log_lines.join.chomp).to eq(test_dir.realpath.to_s)
+  end
+
+  describe '#alive?' do
+    it 'is true if thread is running' do
+      runner = described_class.new(cl: 'sleep 0.05', chdir: test_dir)
+      expect(runner).to be_alive
+    end
+
+    it 'is false if thread is dead' do
+      runner = described_class.new(cl: ':', chdir: test_dir)
+      sleep 0.05
+      expect(runner).to_not be_alive
+    end
+  end
+
+  describe '#successful?' do
+    it 'is true on zero exit status' do
+      runner = described_class.new(cl: 'exit 0', chdir: test_dir)
+      expect(runner).to be_successful
+    end
+
+    it 'is false on nonzero exit status' do
+      runner = described_class.new(cl: 'exit 1', chdir: test_dir)
+      expect(runner).to_not be_successful
+    end
+  end
+
+  describe '#count_lines' do
+    let!(:lns) { <<~SHELL }
+      lns () { i=1; while [ "$i" -le $1 ]; do echo $i; i=$(( i + 1 )); done };
+    SHELL
+
+    context 'dead process' do
+      subject { described_class.new(cl: "#{lns} lns 3", chdir: test_dir) }
+
+      before do
+        subject.successful? # waits on threads
+      end
+
+      it 'plateaus immediately at log lines count' do
+        [3, 3].each { |n| expect(subject.count_lines).to eq(n) }
+      end
+    end
+
+    context 'alive process' do
+      subject { described_class.new(cl: "#{lns} lns 3; sleep 0.20", chdir: test_dir) }
+
+      before do
+        subject
+        sleep 0.02
+      end
+
+      it 'unitarily increases from zero then plateaus at current line count' do
+        [0, 1, 2, 3, 3, 3].each { |n| expect(subject.count_lines).to eq(n) }
+      end
+    end
+  end
+end

data/spec/mnogootex/log/processor_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'yaml'
+
+require 'mnogootex/log/processor'
+
+describe Mnogootex::Log::Processor do
+  describe '.strings_to_lines!' do
+    it 'converts strings into lines' do
+      strings = "foo\nbar\n".lines
+
+      described_class.strings_to_lines! strings
+
+      expect(strings).to eq [
+        Mnogootex::Log::Line.new('foo'),
+        Mnogootex::Log::Line.new('bar')
+      ]
+    end
+  end
+
+  describe '.tag_lines!' do
+    it 'tags using short matchers' do
+      lines = [Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :foo)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq([nil, :foo, nil])
+    end
+
+    it 'tags using long matchers' do
+      lines = [Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :foo, 3)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq([nil, nil, :foo, :foo, :foo, nil, nil])
+    end
+
+    it 'tags abiding to matchers order' do
+      lines = [Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new('something')]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :winner, 1),
+                  Mnogootex::Log::Matcher.new(/foo/, :loser, 1),
+                  Mnogootex::Log::Matcher.new(//, :anything, 1)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq(%i[winner anything])
+    end
+  end
+
+  describe '.filter_lines!' do
+    it 'raises on line with unknown level' do
+      lines = [Mnogootex::Log::Line.new('foo', :bar)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.filter_lines! lines,
+                                      levels: levels,
+                                      min_level: :foo
+      end.to raise_exception KeyError
+    end
+
+    it 'raises on unknown min level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.filter_lines! lines,
+                                      levels: levels,
+                                      min_level: :bar
+      end.to raise_exception KeyError
+    end
+
+    it 'filters tagged lines by minimum level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo),
+               Mnogootex::Log::Line.new('bar', :bar),
+               Mnogootex::Log::Line.new('baz', :baz)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0),
+                 bar: Mnogootex::Log::Level.new(1),
+                 baz: Mnogootex::Log::Level.new(2) }
+
+      described_class.filter_lines! lines,
+                                    levels: levels,
+                                    min_level: :bar
+
+      expect(lines.map(&:text)).to eq(%w[bar baz])
+    end
+  end
+
+  describe '.colorize_lines!' do
+    it 'raises on unknown min level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo)]
+
+      levels = { bar: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.colorize_lines! lines, levels: levels
+      end.to raise_exception KeyError
+    end
+
+    it 'colorizes tagged lines' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo),
+               Mnogootex::Log::Line.new('bar', :bar),
+               Mnogootex::Log::Line.new('baz', :baz)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0, :foo, :red),
+                 bar: Mnogootex::Log::Level.new(1, :bar, :green),
+                 baz: Mnogootex::Log::Level.new(2, :baz, :blue) }
+
+      described_class.colorize_lines! lines, levels: levels
+
+      expect(lines.map(&:text)).to eq %W{\e[0;31;49mfoo\e[0m
+                                         \e[0;32;49mbar\e[0m
+                                         \e[0;34;49mbaz\e[0m}
+    end
+  end
+
+  describe '.render_lines!' do
+    it 'renders lines to indented terminated strings' do
+      lines = [Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new('bar'),
+               Mnogootex::Log::Line.new('baz')]
+
+      described_class.render_lines! lines, indent_width: 2
+
+      expect(lines).to eq ["  foo\n", "  bar\n", "  baz\n"]
+    end
+  end
+
+  describe '#run' do
+    log = <<~LOG
+      This is generic irrelevant information.
+      Hey, I'm warning you, dude. Stuff is gonna get bad.
+      This is also a known irrelevant information flood...
+        ... telling you that you'd better pay attention to warnings.
+      I warned you, dude. Here's an ERROR. :(
+      LOG
+
+    levels = { trace:   Mnogootex::Log::Level.new(0, :trace),
+               warning: Mnogootex::Log::Level.new(1, :warning, :yellow),
+               error:   Mnogootex::Log::Level.new(2, :error, :red) }
+
+    matchers = [Mnogootex::Log::Matcher.new(/error/i, :error, 1),
+                Mnogootex::Log::Matcher.new(/warning/i, :warning, 1),
+                Mnogootex::Log::Matcher.new(/flood/, :trace, 2),
+                Mnogootex::Log::Matcher.new(//, :trace, 1)]
+
+    it 'can be initilized and run' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: true,
+                                         indent_width: 4
+
+      expect(my_processor.run(log.lines)).to eq(
+        ["    \e[0;33;49mHey, I'm warning you, dude. Stuff is gonna get bad.\e[0m\n",
+         "    \e[0;31;49mI warned you, dude. Here's an ERROR. :(\e[0m\n"]
+      )
+    end
+
+    it 'can disable colorization' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: false,
+                                         indent_width: 4
+
+      expect(my_processor.run(log.lines)).to eq(
+        ["    Hey, I'm warning you, dude. Stuff is gonna get bad.\n",
+         "    I warned you, dude. Here's an ERROR. :(\n"]
+      )
+    end
+
+    it 'does not mutate given lines' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: true,
+                                         indent_width: 4
+
+      log_lines = log.lines
+      expect { my_processor.run(log_lines) }.to_not(change { log_lines })
+    end
+  end
+end

data/spec/mnogootex/utils_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'tmpdir'
+
+require 'mnogootex/utils'
+
+describe Mnogootex::Utils do
+  describe '.short_md5' do
+    it 'gives expected hash for empty string' do
+      expect(described_class.short_md5('')).to eq('1B2M2Y8AsgTpgAmY7PhCfg')
+    end
+
+    it 'gives an url/path-safe hash' do
+      expect(described_class.short_md5('Knuth')).to eq('KyIs0ZIec5GkG7_G-clv6Q')
+    end
+  end
+
+  describe '.humanize_bytes' do
+    it 'rounds to smaller unit' do
+      expect(described_class.humanize_bytes(1023 * 1024)).to eq('1023Kb')
+      expect(described_class.humanize_bytes(1024 * 1024)).to eq('1Mb')
+      expect(described_class.humanize_bytes(1025 * 1024)).to eq('1Mb')
+    end
+
+    it 'covers a reasonable scale' do
+      %w[b Kb Mb Gb Tb Pb Eb Zb Yb].each_with_index do |unit, index|
+        expect(described_class.humanize_bytes((2**10)**index)).to eq("1#{unit}")
+      end
+    end
+  end
+
+  describe '.dir_size' do
+    let(:tmpdir) { Pathname.new(Dir.mktmpdir) }
+    before { tmpdir.mkpath }
+    after { tmpdir.rmtree }
+
+    it 'measures an empty dir' do
+      expect(described_class.dir_size(tmpdir)).to eq(0)
+    end
+
+    it 'measures a subtree' do
+      tmpdir.join('foo').write('foo' * 100)
+      tmpdir.join('bar').write('bar' * 200)
+      tmpdir.join('baz').mkpath
+      tmpdir.join('baz', 'qux').write('qux' * 300)
+      # NOTE: dir size is fs dependent, so let's not care about that
+      expect(described_class.dir_size(tmpdir.to_s)).to eq(300 + 600 + tmpdir.join('baz').size + 900)
+    end
+  end
+end