ruby_detective 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20b16d18a1225c536e2ec0cd259b20d0d885658a1cb2c1ca93ae42dac1af4f3c
-  data.tar.gz: f47b00d0f6391ae592c7fd63d1a326d18bbe61ea8f2fa837d43dff4f25074ec7
+  metadata.gz: abe0950ab9ca4d1ed6e201099393deba959859cea88d1d2ca3467dacc38b00d9
+  data.tar.gz: ea9b99edf95de63499ae29a537d2031e312b2c0b7fa7e37947287dd67a96de3c
 SHA512:
-  metadata.gz: 3a3b6cc52488de91de39f1c812ba9a49f040988ff16166b783bad9a6da993054ed464ce2261eacc3010840dd5138752e6eab4abafa14e0fda63d3998ea552df8
-  data.tar.gz: 5cfdf6e719d1a8df329e1e6e55cfce65268f6eec2d1d162e4b96c6f0c2d2189e1a7ecd6cc354c50f44419ce317c6fa4e3c3a855abf9e27e0d47c47818c9395f0
+  metadata.gz: 25e3f035527b125ee423a7b6689889681c935a72c2efe5fe8459cdc649a3050a499421dd005e8f9747b7283a048eda6ff43ca8bfea9439ad5040bfc8935eeb11
+  data.tar.gz: f7b9bb40ec643c51c8e4e2d20bf330a2c2b8b68428c03907f85fffa05cd0ddc46057b866e31510492cdffe1d13fff20acf5787639229b94d7008bafe14b307b2

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+tmp/
+spec/examples.txt
+coverage/
+ruby_detective.html

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format documentation

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    ruby_detective (0.0.0)
+      parser (~> 2.6.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.3.2)
+    json (2.3.0)
+    method_source (0.9.2)
+    parser (2.6.5.0)
+      ast (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  rake (~> 13.0.1)
+  rspec (~> 3.9.0)
+  ruby_detective!
+  simplecov (~> 0.17.1)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Victor A.M. <victor.atmorning@gmail.com.br>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Ruby Detective
+### Investigating your project dependencies
+
+Ruby Detective is a gem that parses your code, finds it's dependencies and outputs a interactive .html file that you can use to explore the dependency network of the code.
+
+This is the UI for the Ruby Detective project by the way :smile:
+
+![Preview](docs/preview.png?raw=true)
+
+***:** Due to Ruby metaprogramming super-powers (and by extension Rails heavy use of those) it's unfeasible to find every single dependency, so we can only guarantee that explicit constants will be pointed as dependencies.
+
+## Main features
+- Explorable and interactive network graph of the project dependencies
+- Graph nodes colored by namespace, making it easier to spot contexts
+- Useful information like lines of code, number of dependencies and dependents, etc
+- Fully self-contained .html file that can be easily shared
+
+## Instalation
+```
+gem install ruby-detective
+```
+
+## Usage
+
+```
+cd my-project-folder
+ruby-detective .
+```
+
+This should output an html file at the end that is completely self-contained, and can be shared around with your peers :D
+
+### Some tips
+- Click on a node to bring it's card to the top of the list on the left
+- Click twice on a node to add it to the graph, allowing to navigate through dependencies
+- Use the filters on the right to customize the graph, toggling off the "Show second-level dependency edges" option can be specially useful

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :test => :spec
+rescue LoadError
+  # no rspec available
+end

data/bin/ruby_detective

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'ruby_detective'
+parser = RubyDetective::Runner.new(ARGV[0])
+parser.run

data/lib/ruby_detective.rb

@@ -3,30 +3,26 @@ end
 
 require "parser/current"
 
-require_relative "ruby_detective/runner"
-require_relative "ruby_detective/json_builder"
-require_relative "ruby_detective/ui_generator"
+require "ruby_detective/runner"
+require "ruby_detective/json_builder"
+require "ruby_detective/ui_generator"
 
-require_relative "ruby_detective/source_representation/data_store"
-require_relative "ruby_detective/source_representation/query"
-require_relative "ruby_detective/source_representation/dependency_resolver"
+require "ruby_detective/source_representation/data_store"
+require "ruby_detective/source_representation/query"
+require "ruby_detective/source_representation/dependency_resolver"
 
-require_relative "ruby_detective/source_representation/entities/base"
-require_relative "ruby_detective/source_representation/entities/klass"
-require_relative "ruby_detective/source_representation/entities/constant"
+require "ruby_detective/source_representation/entities/base"
+require "ruby_detective/source_representation/entities/klass"
+require "ruby_detective/source_representation/entities/constant"
 
-require_relative "ruby_detective/ast/file_parser"
-require_relative "ruby_detective/ast/interpreter"
-require_relative "ruby_detective/ast/node_factory"
+require "ruby_detective/ast/file_parser"
+require "ruby_detective/ast/interpreter"
+require "ruby_detective/ast/node_factory"
 
-require_relative "ruby_detective/ast/nodes/query"
-require_relative "ruby_detective/ast/nodes/generic_node"
-require_relative "ruby_detective/ast/nodes/value_node"
-require_relative "ruby_detective/ast/nodes/constant_reference_node"
-require_relative "ruby_detective/ast/nodes/class_declaration_node"
-require_relative "ruby_detective/ast/nodes/module_declaration_node"
-require_relative "ruby_detective/ast/nodes/absolute_path_sign_node"
-
-if ENV["ENV"] == "development"
-  require "pry"
-end
+require "ruby_detective/ast/nodes/query"
+require "ruby_detective/ast/nodes/generic_node"
+require "ruby_detective/ast/nodes/value_node"
+require "ruby_detective/ast/nodes/constant_reference_node"
+require "ruby_detective/ast/nodes/class_declaration_node"
+require "ruby_detective/ast/nodes/module_declaration_node"
+require "ruby_detective/ast/nodes/absolute_path_sign_node"

data/lib/ruby_detective/ast/file_parser.rb

@@ -0,0 +1,34 @@
+module RubyDetective
+  module AST
+    class FileParser
+      attr_reader :path, :project_path, :rich_ast
+
+      def initialize(file_path, project_path)
+        @path = file_path
+        @project_path = project_path
+      end
+
+      def parse
+        code = File.read(path)
+
+        raw_ast = Parser::CurrentRuby.parse(code)
+        return false if raw_ast.nil? # Empty file scenario
+
+        factory = AST::NodeFactory.new(raw_ast, file_path: clean_path)
+        @rich_ast = factory.build
+        factory.process_all_children
+
+        AST::Interpreter.interpret_node_and_populate_store(
+          rich_ast,
+          clean_path
+        )
+      end
+
+      private
+
+      def clean_path
+        path.sub(project_path, "")
+      end
+    end
+  end
+end

data/lib/ruby_detective/ast/interpreter.rb

@@ -0,0 +1,59 @@
+module RubyDetective
+  module AST
+    class Interpreter
+      attr_reader :rich_ast, :classes, :file_path
+
+      def initialize(rich_ast, file_path)
+        @rich_ast = rich_ast
+        @file_path = file_path
+      end
+
+      def self.interpret_node_and_populate_store(*args)
+        new(*args).interpret_node_and_populate_store
+      end
+
+      def interpret_node_and_populate_store
+        register_classes_and_constants
+
+        true
+      end
+
+      private
+
+      def register_classes_and_constants
+        rich_ast.query.class_declarations.map do |class_node|
+          class_representation = register_class(class_node)
+          register_constants_referenced_in_class(class_representation)
+        end
+      end
+
+      def register_class(node)
+        data_store = SourceRepresentation::DataStore.instance
+        data_store.register_class(
+          node.class_name,
+          node.short_namespace,
+          inheritance_class_name: node.inheritance_class_name,
+          file_path: node.file_path,
+          first_line: node.first_line,
+          last_line: node.last_line
+        )
+      end
+
+      def register_constants_referenced_in_class(class_representation)
+        constant_nodes = rich_ast.query
+          .top_level_constant_references(where: { namespace: class_representation.name })
+          .uniq{ |cr| cr.constant_path } # Removes duplicated constants
+
+        constant_nodes.each do |constant_node|
+          data_store = SourceRepresentation::DataStore.instance
+          data_store.register_constant(
+            constant_node.constant_name,
+            constant_node.constant_path[0..-2],
+            file_path: file_path,
+            caller: class_representation
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_detective/ast/node_factory.rb

@@ -0,0 +1,77 @@
+module RubyDetective
+  module AST
+    class NodeFactory
+      attr_reader :node, :rich_node, :file_path, :parent_node
+
+      # A dictionary that converts the Parser gem type to our Rich AST type
+      NODE_TYPE_DICTIONARY = {
+        const: :constant,
+        class: :class,
+        module: :module,
+        cbase: :absolute_path_sign
+      }
+      # The following types also exist:
+      #
+      # value - the last node of a branch, can be nil, a string, a symbol, etc...
+      # generic - a broader "others" type, for any nodes not mapped out
+
+      def initialize(node, file_path:, parent_node: nil)
+        @node = node
+        @rich_node = nil
+        @file_path = file_path
+        @parent_node = parent_node
+      end
+
+      def build
+        @rich_node = node_class.new(node, file_path: file_path, parent_node: parent_node)
+      end
+
+      def process_all_children
+        rich_node.raw_children.each do |raw_child_node|
+          factory = self.class.new(
+            raw_child_node,
+            file_path: file_path,
+            parent_node: rich_node
+          )
+          child_node = factory.build
+
+          rich_node.children << child_node
+          factory.process_all_children
+        end
+      end
+
+      private
+
+      def node_class
+        case node_type
+        when :class
+          Nodes::ClassDeclarationNode
+        when :module
+          Nodes::ModuleDeclarationNode
+        when :constant
+          Nodes::ConstantReferenceNode
+        when :absolute_path_sign
+          Nodes::AbsolutePathSignNode
+        when :value
+          Nodes::ValueNode
+        when :generic
+          Nodes::GenericNode
+        end
+      end
+
+      def node_type
+        if not_an_ast_node?
+          :value
+        elsif NODE_TYPE_DICTIONARY.key?(node.type)
+          NODE_TYPE_DICTIONARY[node.type]
+        else
+          :generic
+        end
+      end
+
+      def not_an_ast_node?
+        !node.is_a?(Parser::AST::Node)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class AbsolutePathSignNode < GenericNode
+        def type
+          :absolute_path_sign
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class ClassDeclarationNode < GenericNode
+        CLASS_NAME_NODE_INDEX = 0
+        def class_name
+          children[CLASS_NAME_NODE_INDEX].constant_name
+        end
+
+        INHERITANCE_CLASS_NAME_NODE_INDEX = 1
+        def inheritance_class_name
+          inherited_class_constant = children[INHERITANCE_CLASS_NAME_NODE_INDEX]
+          # If this child isn't a ConstantReference node it means it doesn't
+          # have a declared class inheritance like "class Foo::Bar"
+          return unless inherited_class_constant.constant_reference_node?
+
+          inherited_class_constant.constant_name
+        end
+
+        PREPENDED_NAMESPACE_NODE_INDEX = 0
+        def declared_namespace
+          prepended_namespace =
+            children[CLASS_NAME_NODE_INDEX]
+            .children[PREPENDED_NAMESPACE_NODE_INDEX]
+
+          return [class_name] unless prepended_namespace.constant_reference_node?
+          # This scenario happens when we have a class declaration with inline
+          # namespace, like this: class MyNamespace::MyClass
+          prepended_namespace.constant_path + [class_name]
+        end
+
+        def type
+          :class
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module RubyDetective
+  module AST
+    module Nodes
+      class ConstantReferenceNode < GenericNode
+        CONSTANT_NAME_INDEX = 1
+        def constant_name
+          children[CONSTANT_NAME_INDEX].value
+        end
+
+        # A top level constant is for example the "Bar" from "Foo::Bar".
+        # We access it by checking if the parent is another constant, if it is
+        # it means the constant is a nested one and not top level.
+        def top_level_constant?
+          !parent_node.constant_reference_node?
+        end
+
+        # Recursively builds the constant path by traversing it's children,
+        # that way we can compose a path composed of multiple namespaces,
+        # for example: Foo::Bar::Batz as [:Foo, :Bar, :Batz].
+        NESTED_CONSTANT_INDEX = 0
+        def constant_path
+          nested_constant = children[NESTED_CONSTANT_INDEX]
+
+          if nested_constant.constant_reference_node?
+            nested_constant.constant_path + [constant_name]
+          elsif nested_constant.absolute_path_sign_node?
+            # This is used to signify that the constant path was forced to start
+            # from the root, for example: "::Foo::Bar"
+            [:"::"] + [constant_name]
+          else
+            [constant_name]
+          end
+        end
+
+        def type
+          :constant
+        end
+      end
+    end
+  end
+end