163 lines
6.1 KiB
Python
163 lines
6.1 KiB
Python
# Copyright (C) 2009 Google Inc. All rights reserved.
|
|
# Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
|
|
# Copyright (C) 2010 ProFUSION embedded systems
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above
|
|
# copyright notice, this list of conditions and the following disclaimer
|
|
# in the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# * Neither the name of Google Inc. nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
"""Supports reading and processing text files."""
|
|
|
|
import logging
|
|
import sys
|
|
|
|
from webkitpy.common.host import Host
|
|
|
|
|
|
_log = logging.getLogger(__name__)
|
|
|
|
|
|
class TextFileReader(object):
|
|
|
|
"""Supports reading and processing text files.
|
|
|
|
Attributes:
|
|
file_count: The total number of files passed to this instance
|
|
for processing, including non-text files and files
|
|
that should be skipped.
|
|
delete_only_file_count: The total number of files that are not
|
|
processed this instance actually because
|
|
the files don't have any modified lines
|
|
but should be treated as processed.
|
|
|
|
"""
|
|
|
|
def __init__(self, filesystem, processor):
|
|
"""Create an instance.
|
|
|
|
Arguments:
|
|
processor: A ProcessorBase instance.
|
|
|
|
"""
|
|
|
|
self.filesystem = filesystem
|
|
self._processor = processor
|
|
self._files = {}
|
|
self.delete_only_file_count = 0
|
|
|
|
@property
|
|
def file_count(self):
|
|
return len(self._files) - self.delete_only_file_count
|
|
|
|
def _read_lines(self, file_path):
|
|
"""Read the file at a path, and return its lines.
|
|
|
|
Raises:
|
|
IOError: If the file does not exist or cannot be read.
|
|
|
|
"""
|
|
# Support the UNIX convention of using "-" for stdin.
|
|
if file_path == '-':
|
|
file = self.filesystem.open_stdin()
|
|
else:
|
|
# We do not open the file with universal newline support
|
|
# (codecs does not support it anyway), so the resulting
|
|
# lines contain trailing "\r" characters if we are reading
|
|
# a file with CRLF endings.
|
|
file = self.filesystem.open_text_file_for_reading(file_path, 'replace')
|
|
|
|
try:
|
|
contents = file.read()
|
|
finally:
|
|
file.close()
|
|
|
|
lines = contents.split('\n')
|
|
return lines
|
|
|
|
def process_file(self, file_path, **kwargs):
|
|
"""Process the given file by calling the processor's process() method.
|
|
|
|
Args:
|
|
file_path: The path of the file to process.
|
|
**kwargs: Any additional keyword parameters that should be passed
|
|
to the processor's process() method. The process()
|
|
method should support these keyword arguments.
|
|
|
|
Raises:
|
|
SystemExit: If no file at file_path exists.
|
|
|
|
"""
|
|
abs_file_path = self.filesystem.abspath(file_path)
|
|
if abs_file_path not in self._files:
|
|
self._files[abs_file_path] = None
|
|
if kwargs.get('line_numbers'):
|
|
# Deleted files will be 'None', but if a file has modified lines, this information should override the 'None'
|
|
if self._files[abs_file_path] is None:
|
|
self._files[abs_file_path] = []
|
|
self._files[abs_file_path] = self._files[abs_file_path] + kwargs['line_numbers']
|
|
|
|
if not self.filesystem.exists(file_path) and file_path != "-":
|
|
_log.error("File does not exist: '%s'" % file_path)
|
|
raise IOError("File does not exist")
|
|
|
|
if not self._processor.should_process(file_path):
|
|
_log.debug("Skipping file: '%s'" % file_path)
|
|
return
|
|
_log.debug("Processing file: '%s'" % file_path)
|
|
|
|
try:
|
|
lines = self._read_lines(file_path)
|
|
except IOError as err:
|
|
message = ("Could not read file. Skipping: '%s'\n %s" % (file_path, err))
|
|
_log.warn(message)
|
|
return
|
|
|
|
self._processor.process(lines, file_path, **kwargs)
|
|
|
|
def _process_directory(self, directory):
|
|
"""Process all files in the given directory, recursively."""
|
|
for file_path in self.filesystem.files_under(directory):
|
|
self.process_file(file_path)
|
|
|
|
def process_paths(self, paths):
|
|
for path in paths:
|
|
if self.filesystem.isdir(path):
|
|
self._process_directory(directory=path)
|
|
else:
|
|
self.process_file(path)
|
|
|
|
def do_association_check(self, cwd, host=Host()):
|
|
self._processor.do_association_check(self._files, cwd, host=host)
|
|
|
|
def delete_file(self, file_path=None):
|
|
"""Keep track of deleted files.
|
|
|
|
Files which has no modified or newly-added lines don't need
|
|
to check style, but they may effect the association check.
|
|
"""
|
|
if file_path:
|
|
self._files[self.filesystem.abspath(file_path)] = None
|
|
self.delete_only_file_count += 1
|