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"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(consumer = nil) ⇒ Engine

Returns a new instance of Engine.

Parameters:



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:

  • (Boolean) 


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:



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:

  • (Boolean) 


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 {Parser::SyntaxError} when `all_errors_are_fatal`
  is set to true.

Parameters:

Returns:

See Also:

  • #ignore?
  • #raise?


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