Java FileLinesContextFactory类代码示例

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public FlowSquidSensor(Settings settings, CheckFactory checkFactory, FileLinesContextFactory fileLinesContextFactory,
                        FileSystem fileSystem, ResourcePerspectives resourcePerspectives, PathResolver pathResolver) {
logger.debug("** FlowSquidSenser constructor");
this.settings = settings;
this.pathResolver = pathResolver;
   this.checks = checkFactory
     .<SquidCheck<Grammar>>create(CheckList.REPOSITORY_KEY)
     .addAnnotatedChecks((Iterable)CheckList.getChecks(settings.getBoolean(FlowPlugin.IGNORE_TOPLEVEL_KEY),false));
   this.nodeChecks = checkFactory
	      .<SquidCheck<Grammar>>create(CheckList.REPOSITORY_KEY)
	      .addAnnotatedChecks((Iterable)CheckList.getChecks(settings.getBoolean(FlowPlugin.IGNORE_TOPLEVEL_KEY), true));
   this.fileLinesContextFactory = fileLinesContextFactory;
   this.fileSystem = fileSystem;
   this.resourcePerspectives = resourcePerspectives;
   this.mainFilePredicates = fileSystem.predicates().and(
     fileSystem.predicates().hasLanguage(FlowLanguage.KEY),
     fileSystem.predicates().hasType(InputFile.Type.MAIN));
 }
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  WebRulesDefinition rulesDefinition = new WebRulesDefinition();
  RulesDefinition.Context context = new RulesDefinition.Context();
  rulesDefinition.define(context);
  RulesDefinition.Repository repository = context.repository(WebRulesDefinition.REPOSITORY_KEY);

  List<NewActiveRule> ar = new ArrayList<>();
  for (RulesDefinition.Rule rule : repository.rules()) {
    ar.add(new ActiveRulesBuilder().create(RuleKey.of(WebRulesDefinition.REPOSITORY_KEY, rule.key())));
  }
  ActiveRules activeRules = new DefaultActiveRules(ar);

  CheckFactory checkFactory = new CheckFactory(activeRules);
  FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
  when(fileLinesContextFactory.createFor(Mockito.any(InputFile.class))).thenReturn(mock(FileLinesContext.class));
  sensor = new WebSensor(new NoSonarFilter(), fileLinesContextFactory, checkFactory);
  tester = SensorContextTester.create(TEST_DIR);
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public OneCSensor(FileSystem fileSystem, FileLinesContextFactory fileLinesContextFactory, CheckFactory checkFactory) {
    this.fileSystem = fileSystem;
    this.mainFilePredicate = fileSystem.predicates().and(
            fileSystem.predicates().hasType(InputFile.Type.MAIN),
            fileSystem.predicates().hasLanguage(OneC.KEY));
    this.fileLinesContextFactory = fileLinesContextFactory;        
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public FileLinesVisitor(
    FileLinesContextFactory fileLinesContextFactory, 
    FileSystem fileSystem, 
    Map<InputFile, Set<Integer>> linesOfCode) {
    this.fileLinesContextFactory = fileLinesContextFactory;
    this.fileSystem = fileSystem;
    this.allLinesOfCode = linesOfCode;    
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
protected AbstractSensor(FileLinesContextFactory fileLinesContextFactory, NoSonarFilter noSonarFilter, AbstractConfiguration config, EncodingPerFile encodingPerFile,
                         String repositoryKey) {
  this.fileLinesContextFactory = fileLinesContextFactory;
  this.noSonarFilter = noSonarFilter;
  this.config = config;
  this.encodingPerFile = encodingPerFile;
  this.repositoryKey = repositoryKey;
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public TanaguruSensor(
        Tanaguru tanaguru, 
        RulesProfile profile, 
        NoSonarFilter noSonarFilter, 
        ModuleFileSystem fileSystem, 
        FileLinesContextFactory fileLinesContextFactory) {
  this.tanaguru = tanaguru;
  this.noSonarFilter = noSonarFilter;
  this.annotationCheckFactory = AnnotationCheckFactory.create(profile, TanaguruRulesRepository.REPOSITORY_KEY, TanaguruCheckClasses.getCheckClasses());
  this.fileSystem = fileSystem;
  this.fileLinesContextFactory = fileLinesContextFactory;

}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public PuppetSquidSensor(FileLinesContextFactory fileLinesContextFactory, CheckFactory checkFactory, NoSonarFilter noSonarFilter) {
  this.checks = checkFactory
    .<SquidAstVisitor<Grammar>>create(CheckList.REPOSITORY_KEY)
    .addAnnotatedChecks(CheckList.getChecks());
  this.fileLinesContextFactory = fileLinesContextFactory;
  this.noSonarFilter = noSonarFilter;
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public FileLinesVisitor(
  FileLinesContextFactory fileLinesContextFactory,
  FileSystem fileSystem,
  Map<InputFile, Set<Integer>> linesOfCode,
  boolean ignoreHeaderComments) {
  this.fileLinesContextFactory = fileLinesContextFactory;
  this.fileSystem = fileSystem;
  this.allLinesOfCode = linesOfCode;
  this.ignoreHeaderComments = ignoreHeaderComments;
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public static void analyse(SensorContext context, FileLinesContextFactory fileLinesContextFactory, XmlFile xmlFile) {
  LOG.debug("Count lines in " + xmlFile.getAbsolutePath());

  try {
    saveMeasures(
      xmlFile,
      new LineCountParser(xmlFile.getContents(), xmlFile.getCharset()).getLineCountData(),
      fileLinesContextFactory.createFor(xmlFile.getInputFile().wrapped()), context);
  } catch (IOException | SAXException e) {
    LOG.debug("Unable to count lines for file " + xmlFile.getAbsolutePath());
    throw new ParseException(e);
  }
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
public XmlSensor(FileSystem fileSystem, CheckFactory checkFactory, FileLinesContextFactory fileLinesContextFactory) {
  this.fileLinesContextFactory = fileLinesContextFactory;
  this.checks = checkFactory.create(CheckRepository.REPOSITORY_KEY).addAnnotatedChecks((Iterable<?>) CheckRepository.getCheckClasses());
  this.fileSystem = fileSystem;
  this.mainFilesPredicate = fileSystem.predicates().and(
    fileSystem.predicates().hasType(InputFile.Type.MAIN),
    fileSystem.predicates().hasLanguage(Xml.KEY));
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
private void init(boolean activateParsingErrorCheck) throws Exception {
  File moduleBaseDir = new File("src/test/resources");
  context = SensorContextTester.create(moduleBaseDir);

  fs = new DefaultFileSystem(moduleBaseDir);
  fs.setWorkDir(temporaryFolder.newFolder("temp"));

  ActiveRules activeRules = null;
  if (activateParsingErrorCheck) {
    activeRules = new ActiveRulesBuilder()
      .create(ruleKey)
      .activate()
      .create(parsingErrorCheckRuleKey)
      .setInternalKey(parsingErrorCheckKey)
      .activate()
      .build();
  } else {
    activeRules = new ActiveRulesBuilder()
      .create(ruleKey)
      .activate()
      .build();
  }
  CheckFactory checkFactory = new CheckFactory(activeRules);

  FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
  when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(mock(FileLinesContext.class));

  sensor = new XmlSensor(fs, checkFactory, fileLinesContextFactory);
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
@Test
public void should_analyze_file_with_its_own_encoding() throws IOException {
  Charset fileSystemCharset = StandardCharsets.UTF_8;
  Charset fileCharset = StandardCharsets.UTF_16;

  Path moduleBaseDir = temporaryFolder.newFolder().toPath();
  SensorContextTester context = SensorContextTester.create(moduleBaseDir);

  DefaultFileSystem fileSystem = new DefaultFileSystem(moduleBaseDir);
  fileSystem.setEncoding(fileSystemCharset);
  context.setFileSystem(fileSystem);
  String filename = "utf16.xml";
  try (BufferedWriter writer = Files.newBufferedWriter(moduleBaseDir.resolve(filename), fileCharset)) {
    writer.write("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>\n");
    writer.write("<tag></tag>");
  }

  String modulekey = "modulekey";
  DefaultInputFile defaultInputFile = new DefaultInputFile(modulekey, filename)
    .setModuleBaseDir(moduleBaseDir)
    .setType(InputFile.Type.MAIN)
    .setLanguage(Xml.KEY)
    .setCharset(fileCharset);
  defaultInputFile.initMetadata(new FileMetadata().readMetadata(defaultInputFile.file(), fileCharset));
  fileSystem.add(defaultInputFile);

  ActiveRules activeRules = new ActiveRulesBuilder()
    .create(ruleKey)
    .activate()
    .build();
  CheckFactory checkFactory = new CheckFactory(activeRules);

  FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
  when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(mock(FileLinesContext.class));
  sensor = new XmlSensor(fileSystem, checkFactory, fileLinesContextFactory);
  sensor.analyse(context);

  String componentKey = modulekey + ":" + filename;
  assertThat(context.measure(componentKey, CoreMetrics.NCLOC).value()).isEqualTo(2);
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  NewActiveRule ar = new ActiveRulesBuilder().create(RuleKey.of("lua", "S1125")).setSeverity("BLOCKER");
  ActiveRules activeRules = new DefaultActiveRules(Collections.singletonList(ar));
  CheckFactory checkFactory = new CheckFactory(activeRules);
  FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
  when(fileLinesContextFactory.createFor(Mockito.any(InputFile.class))).thenReturn(mock(FileLinesContext.class));
  sensor = new LuaSquidSensor(checkFactory, fileLinesContextFactory);
  tester = SensorContextTester.create(TEST_DIR);
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
private FileLinesContextFactory createFileLinesContextFactory() {
    FileLinesContextFactory fileLinesContextFactory = mock(FileLinesContextFactory.class);
    FileLinesContext fileLinesContext = mock(FileLinesContext.class);
    when(fileLinesContextFactory.createFor(any(InputFile.class))).thenReturn(fileLinesContext);
    return fileLinesContextFactory;
}
 

import org.sonar.api.measures.FileLinesContextFactory; //导入依赖的package包/类
MetricsImporter(SensorContext context, FileLinesContextFactory fileLinesContextFactory, NoSonarFilter noSonarFilter, Predicate<InputFile> inputFileFilter) {
  super(SonarAnalyzer.MetricsInfo.parser(), context, inputFileFilter, SonarAnalyzer.MetricsInfo::getFilePath);
  this.context = context;
  this.fileLinesContextFactory = fileLinesContextFactory;
  this.noSonarFilter = noSonarFilter;
}