/// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text = File.ReadLines(clue.FilePath, clue.Encoding);

            if (text.Count() == 0)
            {
                return("0");
            }

            // 文字数の平均を算出
            var average = text
                          .Select(x => x.Length)
                          .Average();

            // 各行の文字数 - 平均文字数の二乗を合計
            var varianceSum = text
                              .Select(x => Math.Pow(x.Length - average, 2))
                              .Sum();

            // 分散を算出
            var varianceAverage = varianceSum / text.Count();

            // 分散の平方根を返す
            return(Math.Sqrt(varianceAverage).ToString());
        }
Example #2
0
        /// <summary>
        /// 指定されたCOMオブジェクトのインスタンス生成回数を調査します。
        /// </summary>
        /// <param name="clue">調査の入力内容。</param>
        /// <param name="comObjectName">COMオブジェクト名。</param>
        /// <returns>
        /// <paramref name="comObjectName"/> で指定したCOMオブジェクトのインスタンス生成回数を返します。
        /// </returns>
        protected string Do(IScoutingClue clue, string comObjectName)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            const string patternHead = @"\s*=\s*(WScript\.){0,1}CreateObject\(\s*""";
            const string patternTail = @"""\s*\)";
            var          pattern     = patternHead + Regex.Escape(comObjectName) + patternTail;

            var rows  = File.ReadLines(clue.FilePath, clue.Encoding);
            int count = 0;

            foreach (var row in rows)
            {
                var matches = Regex.Matches(row, pattern, RegexOptions.IgnoreCase);

                foreach (var match in matches)
                {
                    var commentHead1 = row.ToLower().IndexOf("rem ");
                    var commentHead2 = row.ToLower().IndexOf("'");
                    var matchIndex   = row.IndexOf(match.ToString());
                    if ((commentHead1 != -1 && matchIndex > commentHead1) ||
                        (commentHead2 != -1 && matchIndex > commentHead2))
                    {
                        continue;
                    }
                    count++;
                }
            }
            return(count.ToString());
        }
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text  = File.ReadLines(clue.FilePath, clue.Encoding);
            int count = 0;

            foreach (var row in text)
            {
                var targets = new string[] { "public sub ", "sub " };
                var blanks  = new char[] { ' ', ' ', '\t' };
                var head    = row.TrimStart(blanks);

                foreach (var target in targets)
                {
                    if (head.ToLower().StartsWith(target))
                    {
                        count++;
                    }
                }
            }
            return(count.ToString());
        }
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("-");
            }

            // ファイルの内容を取得
            var text = File.ReadAllText(clue.FilePath, clue.Encoding);

            // CRの出現数をカウント
            var cr = text.Where(x => x == '\r').Count();

            // CRLFの出現数をカウント
            var crlf     = 0;
            var previous = text[0];

            for (int i = 1; i < text.Length; i++)
            {
                if (previous == '\r' && text[i] == '\n')
                {
                    crlf++;
                }
                previous = text[i];
            }

            // 検出した改行コードを返す
            return(cr > 0 && crlf == 0 ? "CR" :
                   cr == crlf && crlf > 0 ? "CRLF" :
                   cr > 0 && crlf > 0 && cr != crlf ? "CR+CRLF" :
                   "?");
        }
 /// <inheritdoc/>
 public string Do(IScoutingClue clue)
 {
     if (clue.Encoding == null)
     {
         return("unknown");
     }
     return(clue.Encoding.WebName);
 }
 /// <inheritdoc/>
 public string Do(IScoutingClue clue)
 {
     using (var stream = new FileStream(clue.FilePath, FileMode.Open, FileAccess.Read))
     {
         var sha256 = SHA256.Create();
         var hash   = sha256.ComputeHash(stream);
         return(BitConverter.ToString(hash).Replace("-", string.Empty));
     }
 }
Example #7
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            var text   = NumberOfVB6ProcedureRowsScoutingMethod.GetProcedureRows(clue);
            var blanks = new string[] { " ", " " };

            return(text
                   .Where(x => x.RemoveString(blanks).Length == 0)
                   .Count().ToString());
        }
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text = File.ReadLines(clue.FilePath, clue.Encoding);

            return(text
                   .Count().ToString());
        }
Example #9
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text   = File.ReadLines(clue.FilePath, clue.Encoding);
            var blanks = new string[] { " ", " ", "\t" };

            return(text
                   .Where(x => x.RemoveString(blanks).Length == 0)
                   .Count().ToString());
        }
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text   = File.ReadLines(clue.FilePath, clue.Encoding);
            var blanks = new string[] { " ", " ", "\t" };

            return(text
                   .Select(x => x.CountString(blanks))
                   .Sum()
                   .ToString());
        }
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var text = File.ReadLines(clue.FilePath, clue.Encoding);

            if (text.Count() == 0)
            {
                return("0");
            }
            return(text
                   .Select(x => x.Length)
                   .Average().ToString());
        }
Example #12
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            var text = NumberOfVB6ProcedureRowsScoutingMethod.GetProcedureRows(clue);

            int count = 0;

            foreach (var row in text)
            {
                var targets = new string[] { "'", "rem " };
                var blanks  = new char[] { ' ', ' ' };
                var head    = row.TrimStart(blanks);

                foreach (var target in targets)
                {
                    if (head.ToLower().StartsWith(target))
                    {
                        count++;
                    }
                }
            }
            return(count.ToString());
        }
Example #13
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            // バイナリファイルの場合は処理なし
            if (clue.IsBinary)
            {
                return("0");
            }

            var usingTab   = false;
            var usingSpace = false;

            using (var stream = new FileStream(clue.FilePath, FileMode.Open))
                using (var reader = new StreamReader(stream, encoding: clue.Encoding))
                {
                    while (!reader.EndOfStream)
                    {
                        var line = reader.ReadLine();

                        // タブ・スペース使用の反映
                        if (!usingTab)
                        {
                            usingTab = line.IndexOf('\t') > -1;
                        }
                        if (!usingSpace)
                        {
                            usingSpace = line.IndexOf(' ') > -1;
                        }

                        // タブ・スペース混在の場合は1を返す
                        if (usingTab && usingSpace)
                        {
                            return("1");
                        }
                    }
                }

            // 見つからなければ0を返す
            return("0");
        }
Example #14
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            var info = new FileInfo(clue.FilePath);

            return(info.Length.ToString());
        }
Example #15
0
 /// <inheritdoc/>
 public string Do(IScoutingClue clue)
 {
     return(GetProcedureRows(clue).Count().ToString());
 }
Example #16
0
        /// <inheritdoc/>
        public string Do(IScoutingClue clue)
        {
            var info = new FileInfo(clue.FilePath);

            return(info.Name);
        }
Example #17
0
        /// <summary>
        /// SUB/FUNCTIONプロシージャーの行を取得する。
        /// </summary>
        /// <param name="clue">調査の入力内容。</param>
        /// <returns>プロシージャーの行。</returns>
        public static IEnumerable <string> GetProcedureRows(IScoutingClue clue)
        {
            // バイナリファイルの場合は終了
            if (clue.IsBinary)
            {
                yield break;
            }

            // 対象フラグ
            var diggingSub = false;
            var diggingFnc = false;

            // 終端検知時の次行対象外フラグ
            var nextRowIsOutOfSub = false;
            var nextRowIsOutOfFnc = false;

            // カウントを開始する表現
            var subHeads = new string[] { "sub ", "public sub ", "private sub " };
            var fncHeads = new string[] { "function ", "public function ", "private function " };

            // カウントを終了する表現
            const string subTail = "end sub";
            const string fncTail = "end function";

            var text = File.ReadLines(clue.FilePath, clue.Encoding);

            foreach (var row in text)
            {
                // 始端の判定
                bool IsStartingWithThose(string value, string[] heads)
                {
                    foreach (var head in heads)
                    {
                        if (value.ToLower().StartsWith(head))
                        {
                            return(true);
                        }
                    }
                    return(false);
                }

                // 前行が終端ならば次行は対象外
                if (nextRowIsOutOfSub)
                {
                    diggingSub        = false;
                    nextRowIsOutOfSub = false;
                }
                if (nextRowIsOutOfFnc)
                {
                    diggingFnc        = false;
                    nextRowIsOutOfFnc = false;
                }

                // プロシージャの開始・終了を検知
                var blanks  = new char[] { ' ', ' ', '\t' };
                var rowHead = row.TrimStart(blanks);

                // 始端・終端の検知フラグ
                var detectingSubHead = IsStartingWithThose(rowHead, subHeads);
                var detectingFncHead = IsStartingWithThose(rowHead, fncHeads);
                var detectingSubTail = rowHead.ToLower().StartsWith(subTail);
                var detectingFncTail = rowHead.ToLower().StartsWith(fncTail);

                // 始端は対象に含む
                if (!diggingSub && detectingSubHead)
                {
                    diggingSub = true;
                }
                if (!diggingFnc && detectingFncHead)
                {
                    diggingFnc = true;
                }

                // 終端は対象に含む
                if (diggingSub && detectingSubTail)
                {
                    nextRowIsOutOfSub = true;
                }
                if (diggingFnc && detectingFncTail)
                {
                    nextRowIsOutOfFnc = true;
                }

                // 対象ならば行を返す
                if (diggingSub || diggingFnc)
                {
                    yield return(row);
                }
            }
        }
Example #18
0
 /// <inheritdoc/>
 public string Do(IScoutingClue clue)
 {
     return(Do(clue, ComObjectName));
 }