tex_log_parser 1.0.0.pre.10 → 1.0.0.pre.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c466836b3e482413ab935462f0bc513bc7bd43a5
-  data.tar.gz: 8cf420477f87eb3e5cca65db7c5b5dedc1b1129b
+SHA256:
+  metadata.gz: 9452fd78396c5094be2717ac70979ac88892678f73433966ee1ca79ba21fa73d
+  data.tar.gz: 0e72ee4dc90ca406c2ba557eb017bca1c1a6ae682f9b2847d7f391ac4ddf0483
 SHA512:
-  metadata.gz: 7e10d29ce1cfee50a9ee0c6ff16fa57bf76afe91f88b71b81966e7ee12bd469c4995147f76821b8fbba60f7b8ef07bd264fc32500a6dcba25b257a5d5c947ed3
-  data.tar.gz: 93884717b008a2b80f5b7d8aa4e8d9df4e7e4e563beed9e11333bd8bc28a8341b20fdd61b9d61b8c910537c8b5a0bc9cee1e7c207445e3e185348c6a51277ec1
+  metadata.gz: 52cf6f343c49d26fcc9e880301ea082e89f279a65a59ef1bd3c02c25d5810bf05de410224ec28008d55d64b295ea3168b683422b1a85e530a9e886507963da33
+  data.tar.gz: cda1bbf061fb89616784def652834b4020061d020be9c3874099a5bb7b7ed3b165f6343bf00398f3cbdbddae42cf8ab12b41d7dfc87929619c419f2fd56c32e5

data/README.md

@@ -4,7 +4,7 @@
 [![Yard docs](http://img.shields.io/badge/yard-docs-green.svg)](http://www.rubydoc.info/gems/tex_log_parser/1.0.0.pre.2) **˙**
 [![Maintainability](https://api.codeclimate.com/v1/badges/748992a2c5f6570797d4/maintainability)](https://codeclimate.com/github/reitzig/texlogparser/maintainability) 
 [![Test Coverage](https://api.codeclimate.com/v1/badges/748992a2c5f6570797d4/test_coverage)](https://codeclimate.com/github/reitzig/texlogparser/test_coverage) **˙**
-[![Travis build status](https://api.travis-ci.org/reitzig/texlogparser.svg?branch=master)](https://travis-ci.org/reitzig/texlogparser)
+[![Circle CI](https://circleci.com/gh/reitzig/texlogparser.svg?style=svg)](https://circleci.com/gh/reitzig/texlogparser)
 [![Inline docs](http://inch-ci.org/github/reitzig/texlogparser.svg?branch=master)](http://inch-ci.org/github/reitzig/texlogparser)
 
 Eases the many pains around logs from (La)TeX engines. 

data/bin/texlogparser

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require 'tex_log_parser'
-require 'tex_log_parser/version'
+require 'version'
 require 'optparse'
 require 'json'
 
@@ -17,7 +17,7 @@ formats = %i[file_line json]
 OptionParser.new do |opts|
   opts.banner = 'Usage: texlogparser [options]'
   opts.on('-d', '--debug', 'Output debug information') do
-    Logger.debugging = true
+    LogParser::Logger.debug = true
   end
   opts.on('-f ENUM', '--format ENUM', formats,
           'Output format', "One of: #{formats.map(&:to_s).join(', ')}") do |format|
@@ -39,7 +39,7 @@ OptionParser.new do |opts|
     exit
   end
   opts.on_tail('-v', '--version', 'Show version') do
-    puts TexLogParser::VERSION
+    puts "#{File.basename(__FILE__)} #{TexLogParser::VERSION}"
     exit
   end
 
@@ -58,7 +58,7 @@ end
 
 input = STDIN
 input = File.open(options[:input], 'r') if options[:input].is_a?(String)
-parser = TexLogParser.new(input, options)
+parser = TexLogParser.new(input)
 messages = parser.parse
 
 output = STDOUT

data/lib/log_parser/buffer.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module LogParser
+  # Log buffers provide line after line from a given source,
+  # and only store as many lines as necessary:
+  #
+  #  * Read lines from `log` lazily, i.e. only if {find_index} or {[]} are called.
+  #  * Drop lines that are no longer needed, i.e. when {forward} is called.
+  class Buffer
+    # Creates a new buffer that reads lines from the given source.
+    #
+    # @param [Array<String>,IO,StringIO] log
+    #   Where to read log lines from. Can be either an array of `String`,
+    #   an `IO` (e.g. `STDIN`), or a `StringIO`.
+    def initialize(log)
+      @buffer = []
+      @stream = nil
+
+      @buffer = log if log.is_a?(Array)
+      @stream = log if log.is_a?(IO) || log.is_a?(StringIO)
+    end
+
+    # Determines whether there are more lines in this log (buffer).
+    #
+    # @return [true,false]
+    def empty?
+      @buffer.empty? && stream_is_done?
+    end
+
+    # The current size of this buffer, that is the number of lines currently stored.
+    #
+    # @return [Integer]
+    def buffer_size
+      @buffer.size
+    end
+
+    # The first available line, if any.
+    #
+    # _Note:_ Will read from the source if necessary.
+    #
+    # @return [String,nil]
+    def first
+      self[0]
+    end
+
+    # Finds the first index of an element that fulfills a predicate.
+    #
+    # @param [Integer] starting_from
+    #   The first index to check. That is, indices `(0..starting_from - 1)` are skipped.
+    #   *Note:* Indices are relative to the start of the buffer, _not_ the start of the log!
+    #
+    # @yield Invokes a block as predicate over lines.
+    # @yieldparam [String] line
+    #   A line of the log.
+    # @yieldreturn [true,false]
+    #   `true` if (and only if) `line` fulfills the predicate.
+    #
+    # @return [Integer, nil]
+    #   The first index of an element that fulfills the predicate, if any;
+    #   otherwise, `nil`.
+    def find_index(starting_from = 0)
+      index = starting_from
+      element = self[index]
+
+      until element.nil?
+        return index if yield(element)
+        index += 1
+        element = self[index]
+      end
+
+      nil
+    end
+
+    # Retrieves the next `length` many log lines starting from index `offset`.
+    #
+    # @param [Integer] offset
+    #   The first index to retrieve.
+    #   *Note:* Indices are relative to the start of the buffer, _not_ the start of the log!
+    # @param [Integer] length
+    #   The number of elements to retrieve.
+    # @return [String,Array<String>]
+    #   If `length` is set, returns the array of lines with indices in `(offset..offset+length-1)`.
+    #   Otherwise, returns the line with index `offset`.
+    def [](offset, length = nil)
+      base_length = length || 1
+      while offset + base_length > @buffer.size
+        return (length.nil? ? nil : @buffer[offset, @buffer.size]) if stream_is_done?
+        @buffer.push(@stream.readline.rstrip)
+      end
+
+      length.nil? ? @buffer[offset] : @buffer[offset, length]
+    end
+
+    # Moves the front of this buffer forwards by `offset` elements.
+    #
+    # That is, the following code returns `true`:
+    # ```ruby
+    # before = buffer[offset]
+    # buffer.forward[offset]
+    # after = buffer.first
+    # before == after
+    # ```
+    #
+    # @param [Integer] offset
+    #   The number of lines to drop.
+    # @return [void]
+    def forward(offset = 1)
+      self[offset]
+      @buffer.slice!(0, offset)
+    end
+
+    # Closes the `IO` this buffer reads from, if any.
+    #
+    # @return [void]
+    def close
+      @stream.close unless @stream.nil? || @stream.closed?
+    end
+
+    private
+
+    # False if (and only if) this buffer reads from an `IO`,
+    # that `IO` is not closed, and has not yet reached the end.
+    #
+    # @return [true,false]
+    def stream_is_done?
+      @stream.nil? || @stream.closed? || @stream.eof?
+    end
+  end
+end

data/lib/{tex_log_parser → log_parser}/log_parser.rb

@@ -1,29 +1,55 @@
 # frozen_string_literal: true
 
+require 'log_parser/logger'
+require 'log_parser/buffer'
+require 'log_parser/message'
+require 'log_parser/pattern'
+
 # TODO: document
 module LogParser
   attr_reader :messages
   attr_reader :scope_changes_by_line if Logger.debug?
 
   # TODO: document
+  # @return [Array<Message>]
+  def parse
+    skip_empty_lines
+    until empty?
+      parse_next_lines
+      skip_empty_lines
+    end
+
+    # TODO: Remove duplicates?
+    @messages
+  end
+
+  protected
+
+  # Creates a new instance.
+  #
+  # This parser will read lines one by one from the given `log`.
+  # If it is an `IO` or `StringIO`, only those lines currently under investigation will be kept in memory.
+  #
   # @param [Array<String>,IO,StringIO] log
-  # @param [Hash] _options
-  def initialize(log, _options = {})
+  #   A set of log lines that will be parsed.
+  def initialize(log)
     @files = []
 
     @messages = []
     @log_line_number = 1
-    @lines = LogBuffer.new(log)
+    @lines = LogParser::Buffer.new(log)
 
     Logger.debug "Parsing from '#{log}'"
     @scope_changes_by_line = {} if Logger.debug?
   end
 
-  # @return [Array<LogPattern>]
+  # @abstract
+  # @return [Array<Pattern>]
   def patterns
     raise NotImplementedError
   end
 
+  # @abstract
   # @param [String] _line
   # @return [Array<String,:pop>] A list of new scopes this line enters (strings)
   #                              and leaves (`:pop`).
@@ -36,19 +62,6 @@ module LogParser
     @lines.empty?
   end
 
-  # TODO: document
-  # @return [Array<LogMessage>]
-  def parse
-    skip_empty_lines
-    until empty?
-      parse_next_lines
-      skip_empty_lines
-    end
-
-    # TODO: Remove duplicates?
-    @messages
-  end
-
   private
 
   def skip_empty_lines
@@ -59,7 +72,7 @@ module LogParser
   end
 
   # TODO: document
-  # @return [LogMessage,nil]
+  # @return [Message,nil]
   def parse_next_lines
     raise 'Parse already done!' if @lines.empty?
 
@@ -91,16 +104,16 @@ module LogParser
 
   def remove_consumed_lines(i)
     @lines.forward(i)
-    @log_line_number                         += i
+    @log_line_number += i
 
-    @scope_changes_by_line[@log_line_number] = [] if Logger.debug? && i > 0
+    @scope_changes_by_line[@log_line_number] = [] if Logger.debug? && i.positive?
   end
 
-  # @return [LogMessage,nil]
+  # @return [Message,nil]
   def consume_pattern(pattern)
     # Apply the pattern, i.e. read the next message!
 
-    # @type [LogMessage] message
+    # @type [Message] message
     message, consumed_lines = pattern.read(@lines)
     message.log_lines = { from: @log_line_number,
                           to: @log_line_number + consumed_lines - 1 }

data/lib/log_parser/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LogParser
+  # A simple helper, probably to be replaced by a proper logging library
+  # at some point.
+  class Logger
+    class << self
+      # Switches debugging mode on and off.
+      #
+      # @param [true,false] flag
+      # @return [void]
+      def debug=(flag)
+        @debugging = flag
+      end
+
+      # Indicates whether we are debugging.
+      #
+      # @return [true,false]
+      #   `true` if we are in debugging mode, `false` otherwise.
+      def debug?
+        @debugging || !ENV['DEBUG'].nil?
+      end
+
+      # Logs the given message to STDOUT if `debug?` is true.
+      #
+      # @param [String] message
+      # @return [void]
+      def debug(message)
+        puts message if debug?
+      end
+    end
+  end
+end

data/lib/log_parser/message.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module LogParser
+  # A single log message.
+  #
+  # @attr [String] message
+  #   The actual message body from the log.
+  # @attr [String,nil] source_file
+  #   The name of the source file this message originated from.
+  #   `nil` if it could not be determined.
+  # @attr [Hash<Symbol, Int>,nil] source_lines
+  #   A hash with keys `:from` and `:to` mapping to the first and last line index in `source_file` this message pertains to.
+  #   `nil` if they could not be determined.
+  # @attr [Hash<Symbol, Int>,nil] log_lines
+  #   A hash with keys `:from` and `:to` mapping to the first and last line index in the log file that this message covers.
+  #   `nil` if they could not be determined.
+  # @attr [true,false] preformatted
+  #   If `true`, `message` should be printed as-is.
+  #   Otherwise, whitespace can be eliminated.
+  # @attr [:error,:warning,:info,:debug] level
+  #   The severity of this message.
+  # @attr [Class] pattern
+  #   The {LogParser::Pattern} this message was matched by.
+  class Message
+    def initialize(message:, source_file: nil, source_lines: nil, log_lines: nil,
+                   preformatted: false, level: :info, pattern: nil)
+      @message = message
+      @source_file = source_file
+      @source_lines = source_lines
+      @log_lines = log_lines
+      @preformatted = preformatted
+      @level = level
+      @pattern = pattern
+    end
+
+    attr_accessor :message, :source_file, :source_lines, :log_lines,
+                  :preformatted, :level
+
+    # Convert this message to a file-line string representation.
+    #
+    # @return [String]
+    def to_s
+      lines = if @source_lines.nil?
+                ''
+              else
+                # @type [Hash<Symbol, Int>] @source_lines
+                ":#{@source_lines.values.uniq.join('-')}"
+              end
+
+      message = @message
+      message = message.split("\n").map(&:strip).join(' ') unless @preformatted
+      message += "\nLog pattern: '#{@pattern}'" if Logger.debug?
+
+      <<~MSG
+        #{@source_file}#{lines}: #{@level.to_s.upcase}
+        #{message}
+      MSG
+    end
+
+    # Convert this message to JSON.
+    #
+    # @return [String]
+    #   The JSON string representing this message.
+    def to_json(_options = {})
+      hash = {
+        level: @level,
+        source_file: @source_file,
+        source_lines: @source_lines,
+        message: @message,
+        log_lines: @log_lines,
+        preformatted: @preformatted
+      }
+      hash[:pattern] = @pattern if Logger.debug?
+      JSON.pretty_generate hash
+    end
+  end
+end

data/lib/log_parser/pattern.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module LogParser
+  # Represents a certain pattern log message. The model we use is that
+  #  * a pattern tells you if a message starts in a given line, and
+  #  * reads lines from there on until it ends.
+  # The result will be a {Message}.
+  module Pattern
+    # Checks if this message pattern matches the given line.
+    #
+    # @abstract
+    # @param [String] _line
+    #   The log line currently under investigation.
+    # @return [true,false]
+    #   `true` if (and only if) this pattern can parse a single message from the given line onwards.
+    def begins_at?(_line)
+      raise NotImplementedError
+    end
+
+    # Reads a message from the given lines.
+    #
+    # @abstract
+    # @param [LogParser::Buffer] _lines
+    #   A source of log lines to read from.
+    # @return [Array<(Message, Int)>]
+    #   An array of the message that was read, and the number of lines that it spans.
+    # @raise
+    #   If no message end could be found among the given lines.
+    def read(_lines)
+      raise NotImplementedError
+    end
+  end
+
+  # (see Pattern)
+  #
+  # This type of pattern is characterized mainly by two regular expressions:
+  #  * One for matching the first line of a message, and
+  #  * one for matching the last line (+- 1) of a message, which may depend on the first.
+  #
+  # @attr [Regexp] start
+  #   Used to determine where a message starts.
+  #   @see begins_at?
+  #   @see initialize
+  # @attr [MatchData] start_match
+  #   While a message is being processed, this attribute holds the match from the first line.
+  # @attr [Regexp] ending
+  #   Used to determine where a message ends.
+  #   @see ends_at?
+  #   @see initialize
+  module RegExpPattern
+    include Pattern
+
+    # Creates a new instance.
+    #
+    # @param [Regexp] start
+    #   Used to determine where a message starts.
+    #   See also {begins_at?}.
+    # @param [Hash] ending
+    #   Used to determine where a message ends.
+    #   See also {ends_at?}.
+    # @option ending [Regexp] :pattern
+    #   Describes either what all lines of a message look like, or matches the first line not part of the same message.
+    # @option ending [:match,:mismatch] :until
+    #   Determines what is matched against `:pattern`.
+    #    * If `:match`, messages end at the first line that _matches_ `:pattern`.
+    #    * If `:mismatch`, messages end at the first line that does _not_ match `:pattern`.
+    # @option ending [true,false] :inclusive
+    #   Determines whether the first line that (mis)matched `:pattern` should be part of the message.
+    def initialize(start, ending = { pattern: ->(_) { /^\s*$/ },
+                                     until: :match,
+                                     inclusive: false })
+      @start = start
+      @ending = ending
+    end
+
+    # Checks if this message pattern matches the given line,
+    # that is whether the `start` regexp (see {initialize}) matches it.
+    #
+    # @param [String] line
+    #   The log line currently under investigation.
+    # @return [true,false]
+    #   `true` if (and only if) this pattern can parse a single message from the given line onwards.
+    def begins_at?(line)
+      match = @start.match(line)
+      @start_match = match unless match.nil?
+      !match.nil?
+    end
+
+    # Reads a message from the given lines.
+    #
+    # @param [LogParser::Buffer] lines
+    #   A source of log lines to read from.
+    # @return [Array<(Message, Int)>]
+    #   An array of the message that was read, and the number of lines that it spans.
+    # @raise
+    #   If no message end could be found among the given lines.
+    def read(lines)
+      ending = lines.find_index(1) { |l| ends_at?(l) }
+      raise "Did not find end of message (pattern '#{self.class}')." if ending.nil?
+      ending -= 1 unless @ending[:inclusive]
+
+      # Use ending+1 since ending is the index when we drop the first line!
+      msg = LogParser::Message.new(message: lines[0, ending + 1].join("\n"),
+                                   preformatted: true, level: nil,
+                                   pattern: self.class)
+      [msg, ending + 1]
+    end
+
+    protected
+
+    # Checks if the currently read message ends at the given line,
+    # that is whether the `ending[:pattern]` regexp (see {initialize}) matches it.
+    #
+    # @param [String] line
+    #   The log line currently under investigation.
+    # @return [true,false]
+    #   `true` if (and only if) the currently read message ends at the given line.
+    def ends_at?(line)
+      match = @ending[:pattern][@start_match].match(line)
+      @end_match = match unless match.nil?
+      !match.nil? == (@ending[:until] == :match)
+    end
+  end
+end

data/lib/tex_log_parser/patterns/bad_hbox_warning.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
-# TODO: document
-class BadHboxWarning
-  include RegExpPattern
+class TexLogParser
+  # TODO: document
+  class BadHboxWarning
+    include LogParser::RegExpPattern
 
-  def initialize
-    super(/^(Over|Under)full \\hbox.*at lines (\d+)--(\d+)/,
-          { pattern: ->(_) { /^\s*\[\]\s*$/ }, until: :match, inclusive: false }
-    )
-  end
+    # Creates a new instance.
+    def initialize
+      super(/^(Over|Under)full \\hbox.*at lines (\d+)--(\d+)/,
+            { pattern: ->(_) { /^\s*\[\]\s*$/ }, until: :match, inclusive: false }
+      )
+    end
 
-  def read(lines)
-    # @type [LogMessage] msg
-    msg, consumed = super(lines)
+    # (see LogParser::RegExpPattern#read)
+    def read(lines)
+      # @type [Message] msg
+      msg, consumed = super(lines)
 
-    msg.source_lines = { from: @start_match[2].to_i,
-                         to: @start_match[3].to_i }
-    msg.preformatted = true
-    msg.level = :warning
+      msg.source_lines = { from: @start_match[2].to_i,
+                           to: @start_match[3].to_i }
+      msg.preformatted = true
+      msg.level = :warning
 
-    [msg, consumed]
+      [msg, consumed]
+    end
   end
 end

data/lib/tex_log_parser/patterns/fatal_error_occurred.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
-# Matches messages of this form:
-#
-# !  ==> Fatal error occurred, no output PDF file produced!
-# Transcript written on plain.log.
-class FatalErrorOccurred
-  include RegExpPattern
+class TexLogParser
+  # Matches messages of this form:
+  #
+  # !  ==> Fatal error occurred, no output PDF file produced!
+  # Transcript written on plain.log.
+  class FatalErrorOccurred
+    include LogParser::RegExpPattern
 
-  def initialize
-    super(/^\!\s+==>/,
-          { pattern: ->(_) { /Transcript written/ }, until: :match, inclusive: true }
-    )
-  end
+    # Creates a new instance.
+    def initialize
+      super(/^!\s+==>/,
+            { pattern: ->(_) { /Transcript written/ }, until: :match, inclusive: true }
+      )
+    end
 
-  def read(lines)
-    # @type [LogMessage] msg
-    msg, consumed = super(lines)
+    # (see LogParser::RegExpPattern#read)
+    def read(lines)
+      # @type [Message] msg
+      msg, consumed = super(lines)
 
-    msg.level = :error
-    msg.preformatted = false
+      msg.level = :error
+      msg.preformatted = false
 
-    [msg, consumed]
+      [msg, consumed]
+    end
   end
 end

data/lib/tex_log_parser/patterns/file_line_error.rb

@@ -1,29 +1,33 @@
 # frozen_string_literal: true
 
-# Matches messages of this form:
-#
-#   ./plain.tex:31: Undefined control sequence.
-#   l.31 ...t contains some \ref{warnings} and \errors
-#                                                       for testing.
-class FileLineError
-  include RegExpPattern
+class TexLogParser
+  # Matches messages of this form:
+  #
+  #     ./plain.tex:31: Undefined control sequence.
+  #     l.31 ...t contains some \ref{warnings} and \errors
+  #                                                         for testing.
+  class FileLineError
+    include LogParser::RegExpPattern
 
-  def initialize
-    super(%r{^(/?(?:.*?/)*[^/]+):(\d+):})
-  end
+    # Creates a new instance.
+    def initialize
+      super(%r{^(/?(?:.*?/)*[^/]+):(\d+):})
+    end
 
-  def read(lines)
-    # @type [LogMessage] msg
-    msg, consumed = super(lines)
+    # (see LogParser::RegExpPattern#read)
+    def read(lines)
+      # @type [Message] msg
+      msg, consumed = super(lines)
 
-    msg.source_file = @start_match[1]
-    line = @start_match[2].to_i
-    msg.source_lines = { from: line, to: line }
-    msg.preformatted = true
-    msg.level = :error
+      msg.source_file = @start_match[1]
+      line = @start_match[2].to_i
+      msg.source_lines = { from: line, to: line }
+      msg.preformatted = true
+      msg.level = :error
 
-    msg.message.gsub!(@start, '')
+      msg.message.gsub!(@start, '')
 
-    [msg, consumed]
+      [msg, consumed]
+    end
   end
 end