/*

  * This file is part of dependency-check-core.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  *

  * Copyright (c) 2015 Institute for Defense Analyses. All Rights Reserved.

  */

 package org.owasp.dependencycheck.analyzer;

 import org.apache.commons.io.FileUtils;

 import org.owasp.dependencycheck.Engine;

 import org.owasp.dependencycheck.analyzer.exception.AnalysisException;

 import org.owasp.dependencycheck.dependency.Confidence;

 import org.owasp.dependencycheck.dependency.Dependency;

 import org.owasp.dependencycheck.dependency.EvidenceCollection;

 import org.owasp.dependencycheck.utils.FileFilterBuilder;

 import org.owasp.dependencycheck.utils.Settings;

 import java.io.FileFilter;

 import java.io.IOException;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 /**

  * Used to analyze Ruby Gem specifications and collect information that can be used to determine the associated CPE.

  * Regular expressions are used to parse the well-defined Ruby syntax that forms the specification.

  *

  * @author Dale Visser <dvisser@ida.org>

  */

 public class RubyGemspecAnalyzer extends AbstractFileTypeAnalyzer {

     /**

      * The name of the analyzer.

      */

     private static final String ANALYZER_NAME = "Ruby Gemspec Analyzer";

     /**

      * The phase that this analyzer is intended to run in.

      */

     private static final AnalysisPhase ANALYSIS_PHASE = AnalysisPhase.INFORMATION_COLLECTION;

     private static final FileFilter FILTER =

             FileFilterBuilder.newInstance().addExtensions("gemspec").addFilenames("Rakefile").build();

     private static final String EMAIL = "email";

     private static final String GEMSPEC = "gemspec";

     /**

      * @return a filter that accepts files named Rakefile or matching the glob pattern, *.gemspec

      */

     @Override

     protected FileFilter getFileFilter() {

         return FILTER;

     }

     @Override

     protected void initializeFileTypeAnalyzer() throws Exception {

         // NO-OP

     }

     /**

      * Returns the name of the analyzer.

      *

      * @return the name of the analyzer.

      */

     @Override

     public String getName() {

         return ANALYZER_NAME;

     }

     /**

      * Returns the phase that the analyzer is intended to run in.

      *

      * @return the phase that the analyzer is intended to run in.

      */

     @Override

     public AnalysisPhase getAnalysisPhase() {

         return ANALYSIS_PHASE;

     }

     /**

      * Returns the key used in the properties file to reference the analyzer's enabled property.

      *

      * @return the analyzer's enabled property setting key

      */

     @Override

     protected String getAnalyzerEnabledSettingKey() {

         return Settings.KEYS.ANALYZER_RUBY_GEMSPEC_ENABLED;

     }

     /**

      * The capture group #1 is the block variable.

      */

     private static final Pattern GEMSPEC_BLOCK_INIT =

             Pattern.compile("Gem::Specification\\.new\\s+?do\\s+?\\|(.+?)\\|");

     @Override

     protected void analyzeFileType(Dependency dependency, Engine engine)

             throws AnalysisException {

         String contents;

         try {

             contents = FileUtils.readFileToString(dependency.getActualFile());

         } catch (IOException e) {

             throw new AnalysisException(

                     "Problem occurred while reading dependency file.", e);

         }

         final Matcher matcher = GEMSPEC_BLOCK_INIT.matcher(contents);

         if (matcher.find()) {

             contents = contents.substring(matcher.end());

             final String blockVariable = matcher.group(1);

             final EvidenceCollection vendor = dependency.getVendorEvidence();

             addStringEvidence(vendor, contents, blockVariable, "author", Confidence.HIGHEST);

             addListEvidence(vendor, contents, blockVariable, "authors", Confidence.HIGHEST);

             final String email = addStringEvidence(vendor, contents, blockVariable, EMAIL, Confidence.MEDIUM);

             if (email.isEmpty()) {

                 addListEvidence(vendor, contents, blockVariable, EMAIL, Confidence.MEDIUM);

             }

             addStringEvidence(vendor, contents, blockVariable, "homepage", Confidence.MEDIUM);

             final EvidenceCollection product = dependency.getProductEvidence();

             final String name = addStringEvidence(product, contents, blockVariable, "name", Confidence.HIGHEST);

             if (!name.isEmpty()) {

                 vendor.addEvidence(GEMSPEC, "name_project", name + "_project", Confidence.LOW);

             }

             addStringEvidence(product, contents, blockVariable, "summary", Confidence.LOW);

             addStringEvidence(dependency.getVersionEvidence(), contents, blockVariable, "version", Confidence.HIGHEST);

         }

     }

     private void addListEvidence(EvidenceCollection evidences, String contents,

                                  String blockVariable, String field, Confidence confidence) {

         final Matcher matcher = Pattern.compile(

                 String.format("\\s+?%s\\.%s\\s*?=\\s*?\\[(.*?)\\]", blockVariable, field)).matcher(contents);

         if (matcher.find()) {

             final String value = matcher.group(1).replaceAll("['\"]", " ").trim();

             evidences.addEvidence(GEMSPEC, field, value, confidence);

         }

     }

     private String addStringEvidence(EvidenceCollection evidences, String contents,

                                      String blockVariable, String field, Confidence confidence) {

         final Matcher matcher = Pattern.compile(

                 String.format("\\s+?%s\\.%s\\s*?=\\s*?(['\"])(.*?)\\1", blockVariable, field)).matcher(contents);

         String value = "";

         if (matcher.find()) {

             value = matcher.group(2);

             evidences.addEvidence(GEMSPEC, field, value, confidence);

         }

         return value;

     }

 }