Class: Parser::Diagnostic::Engine

Inherits:
Object
  • Object
show all
Defined in:
lib/parser/diagnostic/engine.rb

Overview

Engine provides a basic API for dealing with diagnostics by delegating them to registered consumers.

Examples:

buffer      = Parser::Source::Buffer.new(__FILE__, source: 'foobar')

consumer = lambda do |diagnostic|
  puts diagnostic.message
end

engine     = Parser::Diagnostic::Engine.new(consumer)
diagnostic = Parser::Diagnostic.new(
    :warning, :unexpected_token, { :token => 'abc' }, buffer, 1..2)

engine.process(diagnostic) # => "unexpected token abc"

API:

  • public

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(consumer = nil) ⇒ Engine

Returns a new instance of Engine.

Parameters:

  • (defaults to: nil)

API:

  • public



45
46
47
48
49
50
 
# File 'lib/parser/diagnostic/engine.rb', line 45

def initialize(consumer=nil)
  @consumer             = consumer

  @all_errors_are_fatal = false
  @ignore_warnings      = false
end

Instance Attribute Details

#all_errors_are_fatal ⇒ Boolean

When set to true any error that is encountered will result in SyntaxError being raised.

Returns:

API:

  • public



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/parser/diagnostic/engine.rb', line 36

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

#consumer ⇒ #call(Diagnostic)

Returns:

API:

  • public



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/parser/diagnostic/engine.rb', line 36

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

#ignore_warnings ⇒ Boolean

When set to true warnings will be ignored.

Returns:

API:

  • public



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/parser/diagnostic/engine.rb', line 36

class Diagnostic::Engine
  attr_accessor :consumer

  attr_accessor :all_errors_are_fatal
  attr_accessor :ignore_warnings

  ##
  # @param [#call(Diagnostic)] consumer
  #
  def initialize(consumer=nil)
    @consumer             = consumer

    @all_errors_are_fatal = false
    @ignore_warnings      = false
  end

  ##
  # Processes a `diagnostic`:
  #   * Passes the diagnostic to the consumer, if it's not a warning when
  #     `ignore_warnings` is set.
  #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
  #     is set to true.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Parser::Diagnostic::Engine]
  # @see ignore?
  # @see raise?
  #
  def process(diagnostic)
    if ignore?(diagnostic)
      # do nothing
    elsif @consumer
      @consumer.call(diagnostic)
    end

    if raise?(diagnostic)
      raise Parser::SyntaxError, diagnostic
    end

    self
  end

  protected

  ##
  # Checks whether `diagnostic` should be ignored.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def ignore?(diagnostic)
    @ignore_warnings &&
          diagnostic.level == :warning
  end

  ##
  # Checks whether `diagnostic` should be raised as an exception.
  #
  # @param [Parser::Diagnostic] diagnostic
  # @return [Boolean]
  #
  def raise?(diagnostic)
    (@all_errors_are_fatal &&
        diagnostic.level == :error) ||
      diagnostic.level == :fatal
  end
end

Instance Method Details

#process(diagnostic) ⇒ Parser::Diagnostic::Engine

Processes a diagnostic:

  • Passes the diagnostic to the consumer, if it's not a warning when ignore_warnings is set.
  • After that, raises SyntaxError when all_errors_are_fatal is set to true.

Parameters:

Returns:

See Also:

  • #ignore?
  • #raise?

API:

  • public



64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/parser/diagnostic/engine.rb', line 64

def process(diagnostic)
  if ignore?(diagnostic)
    # do nothing
  elsif @consumer
    @consumer.call(diagnostic)
  end

  if raise?(diagnostic)
    raise Parser::SyntaxError, diagnostic
  end

  self
end