| #!/usr/bin/env python |
| # |
| # This source file is part of the Swift.org open source project |
| # |
| # Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors |
| # Licensed under Apache License v2.0 with Runtime Library Exception |
| # |
| # See http://swift.org/LICENSE.txt for license information |
| # See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| |
| import os |
| import subprocess |
| |
| import util |
| from simplebuild import * |
| |
| class GetFileInfoRule(SimpleAsyncRule): |
| """ |
| Rule which synchronizes the state of external file. |
| """ |
| |
| def __init__(self, path): |
| self.path = str(path) |
| |
| def run(self): |
| util.note("getting file info: %r" % (self.path,)) |
| return util.get_stat_info(self.path) |
| |
| def is_data_valid(self, engine, data): |
| # Check if the current info is up-to-date. |
| util.note("checking file info: %r" % (self.path,)) |
| return util.get_stat_info(self.path) == data |
| |
| class GetDirectoryContentsRule(SimpleAsyncRule): |
| def __init__(self, path): |
| self.path = path |
| |
| def start(self, engine): |
| # Get the file info for the directory, to ensure we treat the external |
| # directory as an input. |
| engine.task_needs_input(self, GetFileInfoRule.asKey(self.path)) |
| |
| def provide_data(self, engine, input_id, data): |
| pass |
| |
| def run(self): |
| util.note("listing directory contents: %r" % (str(self.path),)) |
| try: |
| return sorted(os.listdir(self.path)) |
| except OSError: |
| return [] |
| |
| class SpawnJobRule(SimpleAsyncRule): |
| def __init__(self, args, input_files, output_files, other_inputs=()): |
| self.args = list(args) |
| self.input_files = list(input_files) |
| self.output_files = list(output_files) |
| |
| def start(self, engine): |
| # Request all of the inputs. |
| for path in self.input_files: |
| engine.task_needs_input(self, GetFileInfoRule.asKey(path)) |
| |
| def provide_data(self, engine, input_id, data): |
| pass |
| |
| def run(self): |
| try: |
| util.message(' '.join(self.args)) |
| subprocess.check_call(self.args) |
| except: |
| import traceback |
| traceback.print_exc() |
| util.error("error: command failed: %s" % (' '.join(self.args),)) |
| return { "error" : True } |
| |
| # Get the file info on all of the output files. |
| output_infos = [util.get_stat_info(path) |
| for path in self.output_files] |
| return { "output_info" : output_infos } |
| |
| class CountSourceLinesRule(SimpleAsyncRule): |
| get_dir_input_ID = 0 |
| source_count_input_ID = 1 |
| |
| def __init__(self, path): |
| super(CountSourceLinesRule, self).__init__() |
| self.path = str(path) |
| self.output_paths = None |
| self.result = None |
| |
| def start(self, engine): |
| engine.task_needs_input(self, GetDirectoryContentsRule.asKey(self.path), |
| self.get_dir_input_ID) |
| |
| def provide_data(self, engine, input_id, data): |
| # If this is the directory result, scan it and request individual |
| # counts. |
| if input_id == 0: |
| self.output_paths = [] |
| for input in data: |
| if input.endswith(".c"): |
| input_path = os.path.join(self.path, input) |
| output_path = os.path.join(self.path, input + ".wc") |
| self.output_paths.append(output_path) |
| |
| cmd = ['/bin/sh', '-c', "wc -l < %s > %s" % (input_path, |
| output_path)] |
| engine.task_needs_input( |
| self, SpawnJobRule.asKey(cmd, [input_path], |
| [output_path]), |
| self.source_count_input_ID) |
| return |
| |
| def run(self): |
| # Gather all the results. |
| self.result = 0 |
| for path in self.output_paths: |
| with open(path) as f: |
| self.result += int(f.read()) |
| return self.result |
| |
| # Get the input path. |
| _,path = sys.argv |
| |
| # Run the job |
| engine = DataDrivenEngine(globals()) |
| engine.attach_db(".count-source-lines-with-wc.db") |
| |
| result = engine.build(CountSourceLinesRule.asKey(path)) |
| print result |