code_reference_finder 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9af7b22c3b5a984cd962a855e4b60a910e748979d869a15a244a386f032bba06
+  data.tar.gz: 6f3125078a4f4d60a005fa392138e7d7eca082a207db5a00fa327c97836cbe93
+SHA512:
+  metadata.gz: c04d79e144283a4163fa7dec0733af9b1686b2c41d8a0048c34fae05c6832c0090127267e15cbe12a38031f7ec244ccb2dae27b12f95bf93a5f2e25e52fb55ea
+  data.tar.gz: c4ff575f231b3db942c1f0d4231416280c77118423a47c358712f56df10517f4917e55abf27689e2f3a73f15b388b4f4798cf8f53f8872270637fe1273be8875

data/lib/code_reference_finder.rb

@@ -0,0 +1,136 @@
+# This is a source code analyzer for finding files containing specific references.
+
+class CodeReferenceFinder
+    def initialize(dir:, ext:, target:, ignore:)
+        @dir = dir
+        @ext = ext
+        @target = target
+        @ignore = ignore
+        @results = nil
+        @interesting_paths = nil
+    end
+
+    # Performs a parse and returns JSON results.
+    def get_json
+        @interesting_paths = find_interesting_paths()
+        json = parse_interesting_paths(@interesting_paths)
+        json
+    end
+
+    # Returns the result hash, nil if unparsed.
+    def get_results
+        @results
+    end
+
+    # Returns the interesting paths array, nil if unparsed.
+    def get_interesting_paths
+        @interesting_paths
+    end
+
+    private
+
+    attr_reader :results, :interesting_paths
+
+    # First pass pre-processing to locate files of interest to parse.
+    def find_interesting_paths
+        require 'find'
+
+        src_paths = []
+        Find.find(@dir) do |path|
+            src_paths << path if path.end_with? @ext
+        end
+
+        search_file_paths = []
+        src_paths.each do |path|
+            File.open(path) do |f|
+                f.each_line do |line|
+                    if @target.any? {|s| line.include? s}
+                        search_file_paths << path unless search_file_paths.include? path
+                    end
+                end
+            end
+        end
+
+        search_file_paths
+    end
+
+    # Where the magic happens.
+    def parse_interesting_paths(interesting_paths)
+        require 'json'
+
+        def is_comment?(line)
+            line.start_with? '*' or line.start_with? '/*' or line.start_with? '//'
+        end
+        
+        def is_call?(line, ref)
+            line.include? "#{ref}." or line.include? "(#{ref}" or line.include? "#{ref})"
+        end
+
+        def is_ref_search_match?(line, refs)
+            tokens = line.split(' ')
+            matches = []
+            refs.each {|ref| matches << ref if tokens.include? ref }
+            matches.size > 0
+        end
+
+        def is_ignorable?(line)
+            @ignore.any? {|s| line.include? s}
+        end
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        file_matches = {}
+        refined_target = @target.map {|s| s.split(' ').last}
+
+        # Loop through interesting paths to find targets and references to targets.
+        # Add the results of the parse to the file_matches hash.
+        interesting_paths.each do |path|
+            name = path[path.rindex('/') + 1..].sub(@ext, '').strip
+            line_matches = []
+            ref_searches = []
+            i = 0
+        
+            File.open(path) do |f|
+                f.each_line do |line|
+                    i += 1
+                    next if is_comment?(line.strip!)
+
+                    if refined_target.any? {|s| line.include? s} and not is_ignorable?(line)
+                        line_matches << "#{i}: #{line}"
+        
+                        if line.include? ' = '
+                            search = line.strip.split('=')[0].split(' ').last
+                            ref_searches << search if not ref_searches.include? search
+                        end
+                    elsif ref_searches.any? {|s| is_call?(line, s)} or is_ref_search_match?(line, ref_searches)
+                        line_matches << "#{i}: #{line}"
+                    end
+                end
+            end
+        
+            file_matches[name] = { 
+                :path => path, 
+                :line_count => i, 
+                :ref_count => ref_searches.size, 
+                :match_count => line_matches.size, 
+                :refs => ref_searches, 
+                :matches => line_matches 
+            }
+        end
+
+        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        
+        # Define our results hash and return it as a JSON string.
+        @results = { 
+            :params => {
+                :dir => @dir,
+                :ext => @ext,
+                :target => @target,
+                :ignore => @ignore
+            },
+            :duration => "#{end_time - start_time} seconds",
+            :file_matches => file_matches 
+        }
+        JSON.pretty_generate(@results)
+    end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: code_reference_finder
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Scott Stauffer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-02-10 00:00:00.000000000 Z
+dependencies: []
+description: A source code analyzer to find targets and their references in very large
+  solutions.
+email: scott@fuseraft.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/code_reference_finder.rb
+homepage: https://rubygems.org/gems/code_reference_finder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: A source code analyzer to find targets and their references in very large
+  solutions.
+test_files: []