def parse(self, line):
     for t in maybe(self._match_last_line(line)):
         self._extra_line(t)
         return self.finish()
     for t in maybe(self._match_line(line)):
         self._extra_line(t)
         return self
     return self.finish()

 def mark_errors_in(self, filename):
     for errors in maybe(self._error_report.sorted_errors_in(filename)):
         for view in self._file_views(filename):
             if view.is_dirty():
                 self._highlighter.clear(view)
             else:
                 self._highlighter.highlight(view, errors, replace=True)

 def start(cls, project, line):
     for m in maybe(re.match(r'\[(?:error|info)\]\s+(.+)\s+\(([^:]+):(\d+)\)$', line)):
         yield cls(project,
                   line=line,
                   filename=m.group(2),
                   lineno=int(m.group(3)),
                   message=m.group(1))

    def sorted_errors_in(self, filename):
        def sort_errors(errors):
            for line in sorted(errors.keys()):
                for error in sorted(errors[line], key=lambda e: e.error_type):
                    yield error

        for errors in maybe(self.errors_in(filename)):
            return list(sort_errors(errors))

 def _bookmark_error(self, view):
     for error in maybe(self._current_error_in_view(view)):
         region = self._create_region(view, error.line)
         self._clear_highlight(view, region)
         view.add_regions(self.bookmark_key,
                          [region],
                          self.region_scope(error.error_type),
                          *self._bookmark_args(error.error_type))
         return error.line

 def is_sbt_view(cls, view):
     if view is not None:
         for window in maybe(view.window()):
             sbt_view = cls(window)
             return sbt_view.panel.id() == view.id()

 def _status_message(self, view):
     for errors in maybe(self._line_errors(view)):
         return '(%s)' % ')('.join([e.message for e in errors])

 def on_activated(self, view):
     for reporter in maybe(self._reporter(view)):
         reporter.show_errors_in(view.file_name())

 def _reporter(self, view):
     for window in maybe(view.window()):
         return Project(window).error_reporter

 def is_play_project(self):
     for root in maybe(self.project_root()):
         if self._play_build_files(root):
             return True

 def error_lines_in(self, filename):
     for errors in maybe(self.errors_in(filename)):
         return sorted(errors.keys())

 def _match_line(self, line):
     for m in maybe(re.match(r'\[info\] (.*)$', line)):
         return m.group(1)

 def mark_settings(self, error_type='error'):
     for settings in maybe(self.get('%s_marking' % error_type)):
         return settings
     return self.global_mark_settings()

 def _view_settings(self):
     for view in maybe(self.window.active_view()):
         return view.settings().get('SublimeSBT', {})
     return {}

 def update_status_now(self):
     for view in maybe(self._window.active_view()):
         self._highlighter.set_status_message(view, self._status_message(view))

 def current_error_in(self, filename):
     for error in maybe(self.current_error):
         if error.filename == filename:
             return error

 def on_modified(self, view):
     for reporter in maybe(self._reporter(view)):
         reporter.show_errors(view.file_name())

 def _match_last_line(self, line):
     for m in maybe(re.match(r'\[info\] (.+) \(([^:]+):(\d+)\)$', line)):
         return (m.group(1), m.group(2), int(m.group(3)))

 def errors_at(self, filename, line):
     for errors in maybe(self.errors_in(filename)):
         return errors.get(line)

 def on_post_save(self, view):
     for reporter in maybe(self._reporter(view)):
         reporter.hide_errors_in(view.file_name())