ruby_detective 0.0.1 → 0.0.2

data/lib/ruby_detective/ast/nodes/generic_node.rb

@@ -0,0 +1,87 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class GenericNode
+        attr_reader :ast_node, :children, :file_path, :parent_node
+
+        def initialize(ast_node, file_path:, parent_node:)
+          @ast_node = ast_node
+          @file_path = file_path
+          @children = []
+          @parent_node = parent_node
+        end
+
+        def short_namespace
+          namespace[0..-2]
+        end
+
+        def namespace
+          build_namespace(self)
+        end
+
+        def declared_namespace
+          []
+        end
+
+        def class_declaration_node?
+          type == :class
+        end
+
+        def module_declaration_node?
+          type == :module
+        end
+
+        def constant_reference_node?
+          type == :constant
+        end
+
+        def absolute_path_sign_node?
+          type == :absolute_path_sign
+        end
+
+        def value_node?
+          type == :value
+        end
+
+        def generic_node?
+          type == :generic
+        end
+
+        def type
+          :generic
+        end
+
+        def first_line
+          # When the node represents something that is not directly in the code
+          # the `ast_node.loc.expression` can be nil, and since `.line` is just
+          # sugar syntax for `loc.expression.line` it would throw an error.
+          ast_node.loc.line rescue nil
+        end
+
+        def last_line
+          # When the node represents something that is not directly in the code
+          # the `ast_node.loc.expression` can be nil, and since `.last_line` is just
+          # sugar syntax for `loc.expression.last_line` it would throw an error.
+          ast_node.loc.last_line rescue nil
+        end
+
+        def query
+          Query.new(self)
+        end
+
+        def raw_children
+          ast_node.children
+        end
+
+        private
+
+        def build_namespace(node, acc = [])
+          return acc.flatten.compact if node.nil?
+
+          acc.prepend(node.declared_namespace)
+          build_namespace(node.parent_node, acc)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_detective/ast/nodes/module_declaration_node.rb

@@ -0,0 +1,21 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class ModuleDeclarationNode < GenericNode
+        MODULE_NAME_NODE_INDEX = 0
+        def module_name
+          children[MODULE_NAME_NODE_INDEX].constant_name
+        end
+
+        # TODO: Add support for inline namespacing (ex class Foo::Bar)
+        def declared_namespace
+          [module_name]
+        end
+
+        def type
+          :module
+        end
+      end
+    end
+  end
+end

data/lib/ruby_detective/ast/nodes/query.rb

@@ -0,0 +1,82 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class Query
+        attr_reader :node
+
+        def initialize(node)
+          @node = node
+        end
+
+        # TODO: accept multiple criteria
+        def where(criteria = {})
+          case
+          when criteria.key?(:type)
+            type_validation_function = ->(node) { node.type == criteria[:type] }
+            deep_search(node, [type_validation_function])
+          else
+            deep_search(node)
+          end
+        end
+
+        # TODO: ignore constant definitions, only return constant references
+        def constant_references(where: {})
+          constants = deep_search(node, [:constant_reference_node?])
+
+          case
+          when where.key?(:namespace)
+            constants.select { |c| c.namespace.include?(where[:namespace].to_sym) }
+          else
+            constants
+          end
+        end
+
+        # TODO: ignore constant definitions, only return constant references
+        # This finds all constants, ignoring the nested ones.
+        # For example:
+        # The "Foo::Bar" code contain two constants, but this method will only bring
+        # up one (the Bar one), with access to it's full path.
+        def top_level_constant_references(where: {})
+          constants = deep_search(node, [:constant_reference_node?, :top_level_constant?])
+
+          case
+          when where.key?(:namespace)
+            constants.select { |c| c.namespace.include?(where[:namespace].to_sym) }
+          else
+            constants
+          end
+        end
+
+        def class_declarations
+          deep_search(node, [:class_declaration_node?])
+        end
+
+        private
+
+        def deep_search(node, validation_methods = [], acc: [])
+          return if node.value_node?
+
+          validation_result = validation_methods.map do |validation_method|
+            if validation_method.is_a?(Symbol)
+              node.respond_to?(validation_method) && node.public_send(validation_method)
+            elsif validation_method.is_a?(Proc)
+              begin
+                validation_method.call(node)
+              rescue NoMethodError
+                false
+              end
+            else
+              raise ArgumentError, "Unexpected validation method data type"
+            end
+          end
+
+          # Only appends the node to the results if all validations passed
+          acc << node if validation_result.all?
+
+          node.children.each { |child| send(__method__, child, validation_methods, acc: acc) }
+          acc.uniq
+        end
+      end
+    end
+  end
+end

data/lib/ruby_detective/ast/nodes/value_node.rb

@@ -0,0 +1,30 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class ValueNode < GenericNode
+        attr_reader :value
+
+        def initialize(value, *args)
+          super(value, *args)
+          @value = value
+        end
+
+        def type
+          :value
+        end
+
+        def first_line
+          parent_node.first_line
+        end
+
+        def last_line
+          parent_node.last_line
+        end
+
+        def raw_children
+          []
+        end
+      end
+    end
+  end
+end

data/lib/ruby_detective/json_builder.rb

@@ -0,0 +1,30 @@
+require "json"
+
+module RubyDetective
+  class JSONBuilder
+    attr_reader :classes
+
+    def initialize
+      data_store = SourceRepresentation::DataStore.instance
+      @classes = data_store.classes
+    end
+
+    def self.build(*args)
+      new(*args).build
+    end
+
+    def build
+      classes_data_as_json = classes.map do |c|
+        {
+          name: c.name,
+          full_name: c.path_as_text,
+          namespace: c.namespace_as_text,
+          lines_of_code: c.lines_of_code,
+          dependencies: c.dependencies.map(&:path_as_text),
+          dependents: c.dependents.map(&:path_as_text),
+          file_path: c.file_path
+        }
+      end.to_json
+    end
+  end
+end

data/lib/ruby_detective/runner.rb

@@ -0,0 +1,39 @@
+require "parser/current"
+
+module RubyDetective
+  class Runner
+    attr_reader :project_path, :classes, :modules
+
+    def initialize(project_path)
+      if [nil, "", " "].include? project_path
+        @project_path = "."
+      else
+        @project_path = project_path
+      end
+    end
+
+    def run
+      puts "Processing files..."
+      Dir.glob("#{project_path}/**/*.rb") do |file_path|
+        AST::FileParser.new(file_path, project_path).parse
+      end
+
+      puts "Finding dependencies..."
+      SourceRepresentation::DataStore.instance.resolve_dependencies
+
+      if ENV["ENV"] == "development"
+        puts "Generating output .json file..."
+        json = ::RubyDetective::JSONBuilder.build
+
+        output_file_path = "ui/src/data.json"
+        File.delete(output_file_path) if File.exist?(output_file_path)
+        File.open(output_file_path, "w") { |file| file << json }
+      else
+        puts "Generating output HTML file..."
+        UIGenerator.generate
+      end
+
+      puts "Done!"
+    end
+  end
+end

data/lib/ruby_detective/source_representation/data_store.rb

@@ -0,0 +1,67 @@
+require "singleton"
+
+# This class is used as a database of sorts during the
+# analysis execution.
+module RubyDetective
+  module SourceRepresentation
+    class DataStore
+      include Singleton
+
+      attr_accessor :classes, :constants
+
+      def initialize
+        @classes = []
+        @constants = []
+      end
+
+      def query
+        Query.new
+      end
+
+      def clear!
+        initialize
+      end
+
+      def inspect
+        "#<RubyDetective::SourceRepresentation::DataStore>"
+      end
+
+      def resolve_dependencies
+        DependencyResolver.resolve_and_populate_store
+      end
+
+      def register_class(name, namespace, inheritance_class_name:, file_path:, first_line:, last_line:)
+        klass = Entities::Klass.new(
+          name,
+          namespace,
+          inheritance_class_name: inheritance_class_name,
+          file_path: file_path,
+          first_line: first_line,
+          last_line: last_line
+        )
+
+        existing_class = query.classes(where: { path: klass.path }).first
+
+        if existing_class
+          existing_class.merge(klass)
+          existing_class
+        else
+          @classes << klass
+          klass
+        end
+      end
+
+      def register_constant(name, namespace, file_path:, caller:, refers_to: nil)
+        constant = Entities::Constant.new(
+          name,
+          namespace,
+          caller: caller,
+          refers_to: refers_to,
+          file_path: file_path
+        )
+        @constants << constant
+        constant
+      end
+    end
+  end
+end

data/lib/ruby_detective/source_representation/dependency_resolver.rb

@@ -0,0 +1,41 @@
+module RubyDetective
+  module SourceRepresentation
+    class DependencyResolver
+      attr_reader :classes
+
+      def initialize
+        @classes = DataStore.instance.classes
+      end
+
+      def self.resolve_and_populate_store
+        new.resolve_and_populate_store
+      end
+
+      def resolve_and_populate_store
+        register_dependencies_and_dependents
+        true
+      end
+
+      private
+
+      def register_dependencies_and_dependents
+        classes.each do |klass|
+          klass.constants.each do |constant|
+            referred_class = find_referred_class(constant)
+            next if referred_class.nil?
+
+            constant.register_referred_class(referred_class)
+          end
+        end
+      end
+
+      def find_referred_class(constant)
+        classes.select do |klass|
+          constant.possible_paths_of_referenced_entity.find do |possible_path|
+            klass.path == possible_path
+          end
+        end.compact.first
+      end
+    end
+  end
+end

data/lib/ruby_detective/source_representation/entities/base.rb

@@ -0,0 +1,46 @@
+module RubyDetective
+  module SourceRepresentation
+    module Entities
+      class Base
+        ROOT_SIGN_SYMBOL = :"::"
+
+        def absolute_path?
+          namespace.first == ROOT_SIGN_SYMBOL
+        end
+
+        def path
+          namespace + [name]
+        end
+
+        def path_without_root_sign
+          namespace_without_root_sign + [name]
+        end
+
+        # Removes the :"::" symbol from the namespace
+        def namespace_without_root_sign
+          if absolute_path?
+            namespace[1..-1]
+          else
+            namespace
+          end
+        end
+
+        def path_as_text
+          if absolute_path?
+            "::" + path_without_root_sign.join("::")
+          else
+            path.join("::")
+          end
+        end
+
+        def namespace_as_text
+          if absolute_path?
+            "::" + namespace_without_root_sign.join("::")
+          else
+            namespace.join("::")
+          end
+        end
+      end
+    end
+  end
+end