deps_grapher 1.0.0

data/lib/deps_grapher/ast_processor.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "parser/current"
+require_relative "source_cache"
+require_relative "node"
+require_relative "edge"
+
+module DepsGrapher
+  class AstProcessor < Parser::AST::Processor
+    include Logging
+
+    class << self
+      def processed
+        @processed ||= Set.new
+      end
+
+      def event_processed
+        @event_processed ||= Set.new
+      end
+
+      attr_writer :depth
+
+      def depth
+        @depth ||= 0
+      end
+    end
+
+    def initialize(file_path, graph, event_processors, advanced_const_resolver, ignore_errors)
+      super()
+      @file_path = file_path
+      @target = File.basename(file_path, ".*").camelize
+      @graph = graph
+      @event_processors = event_processors
+      @advanced_const_resolver = advanced_const_resolver
+      @ignore_errors = ignore_errors
+    end
+
+    def call
+      return if self.class.processed.include?(@file_path)
+
+      log do
+        source_buffer = Parser::Source::Buffer.new(@file_path)
+        parser = Parser::CurrentRuby.new
+        process parser.parse(source_buffer.read)
+      end
+    end
+
+    def on_module(ast_node)
+      const_node = ast_node.children[0]
+      name = extract_const_name const_node
+
+      @namespace_stack ||= []
+      @namespace_stack.push name
+
+      if name == @target
+        fully_qualified_class_name = @namespace_stack.join "::"
+        @current_node = Node.add fully_qualified_class_name, @file_path
+        self.class.processed << @file_path
+      end
+
+      super
+
+      @namespace_stack.pop
+    end
+    alias on_class on_module
+
+    def on_const(ast_node)
+      const_name = extract_const_name ast_node
+
+      process_recursively! const_name, ast_node do
+        Event.add name: :const_found, const_name: _1, location: _2
+      end
+
+      super
+    end
+
+    def on_send(ast_node)
+      if @current_node
+        receiver_node, method_name, = *ast_node
+
+        const_name = call_advanced_const_resolver ast_node
+        const_name ||= extract_const_name receiver_node
+
+        process_recursively! const_name, receiver_node do
+          Event.add name: :method_found, const_name: _1, location: _2, method: method_name
+        end
+      end
+
+      super
+    end
+
+    private
+
+    def call_event_processor(event)
+      return if event.blank? || @event_processors.blank?
+      return if self.class.event_processed.include?(event.key)
+
+      self.class.event_processed << event.key
+
+      @event_processors.each do |matcher, (prop, event_processor)|
+        if matcher.is_a?(Regexp)
+          next unless matcher.match? event.send(prop)
+        else
+          next unless matcher == event.send(prop)
+        end
+
+        event_processor.call event
+      end
+    end
+
+    def call_advanced_const_resolver(ast_node)
+      return nil unless @advanced_const_resolver.respond_to?(:call)
+
+      @advanced_const_resolver.call ast_node
+    end
+
+    def process_recursively!(const_name, ast_node)
+      return unless @current_node
+
+      begin
+        const_name, location = if ast_node
+                                 guess_source_location(const_name, ast_node)
+                               else
+                                 find_source_location!(const_name)
+                               end
+      rescue SourceLocationNotFound => e
+        raise e unless @ignore_errors
+      end
+
+      return unless const_name && location
+
+      event = yield const_name, location
+      call_event_processor event
+
+      return unless event&.processing?
+
+      node = Node.add const_name, location
+      edge = Edge.add @current_node, node
+
+      return unless edge
+
+      @graph.add_edge edge
+
+      self.class.new(
+        node.location,
+        @graph,
+        @event_processors,
+        @advanced_const_resolver,
+        @ignore_errors
+      ).call
+    end
+
+    def extract_const_name(ast_node)
+      return nil if ast_node.nil?
+
+      return nil unless ast_node.type == :const
+
+      base, name = *ast_node
+      if base.nil?
+        name.to_s
+      else
+        [extract_const_name(base), name].compact.join "::"
+      end
+    end
+
+    def guess_namespace(file_path)
+      const_name = SourceCache::Registry.fetch(file_path)
+      namespace = const_name.split("::")
+      parts = namespace.last
+      while parts.present?
+        return if yield(namespace)
+
+        parts = namespace.pop
+      end
+    end
+
+    def guess_source_location(const_name, ast_node)
+      return if const_name.blank?
+
+      find_source_location! const_name
+    rescue SourceLocationNotFound
+      guess_namespace(ast_node.location.name.source_buffer.name) do |ns|
+        return find_source_location! [*ns, const_name].compact.join("::")
+      rescue SourceLocationNotFound
+        nil
+      end
+    end
+
+    def find_source_location!(const_name)
+      return if const_name.blank?
+
+      location = SourceCache::Registry.fetch const_name
+      [const_name, location]
+    rescue SourceCacheNotFound
+      raise SourceLocationNotFound, "source location not found for #{const_name}"
+    end
+
+    def log
+      verbose do
+        indent = "*" * self.class.depth
+        indent << " " if indent.present?
+        "Analyzing #{indent}#{@file_path}"
+      end
+
+      self.class.depth += 1
+      yield
+    ensure
+      self.class.depth -= 1
+    end
+  end
+end

data/lib/deps_grapher/ast_processor_policy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class AstProcessorPolicy
+    def initialize(context, &block)
+      @context = context
+      DSL.new(self).instance_eval(&block)
+    end
+
+    def const(matcher, &block)
+      event_processor matcher, :const_name, &block
+    end
+
+    def include_const(matcher)
+      const matcher, &:processing!
+    end
+
+    def exclude_const(matcher)
+      const matcher, &:skip_processing!
+    end
+
+    def location(matcher, &block)
+      event_processor matcher, :location, &block
+    end
+
+    def include_location(matcher)
+      location matcher, &:processing!
+    end
+
+    def exclude_location(matcher)
+      location matcher, &:skip_processing!
+    end
+
+    def event_processor(matcher, prop, &block)
+      @context.event_processors[matcher] = [prop, block]
+    end
+
+    def advanced_const_resolver(callable = nil, &block)
+      raise ArgumentError, "You must provide a block or callable" unless block || callable
+      raise ArgumentError, "The provided object must respond to #call" if callable && !callable.respond_to?(:call)
+
+      @context.advanced_const_resolver = block || callable
+    end
+  end
+end

data/lib/deps_grapher/cache_file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class CacheFile
+    include Logging
+
+    def initialize(file:, ttl:)
+      @file = file
+      @ttl = ttl
+    end
+
+    def write(target)
+      return if File.exist?(@file)
+
+      FileUtils.mkdir_p File.dirname(@file)
+
+      info { "Writing cache to #{@file}" }
+
+      File.open(@file, "w") do |f|
+        Marshal.dump target, f
+      end
+    end
+
+    def read
+      return nil unless File.exist?(@file)
+
+      info { "Reading cache from #{@file} (#{File.size(@file)} bytes)" }
+
+      File.open(@file) do |f|
+        return Marshal.load f
+      end
+    end
+
+    def stale?
+      return false unless File.exist?(@file)
+
+      File.mtime(@file).to_i < (Time.now.to_i - @ttl)
+    end
+
+    def clean!(force: false)
+      return unless File.exist?(@file)
+      return unless force || stale?
+
+      FileUtils.rm_f @file
+      info { "Removed stale cache file: #{@file}" }
+    end
+  end
+end

data/lib/deps_grapher/cli.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class Cli
+    include Logging
+
+    STATUS_SUCCESS = 0
+    STATUS_FAILURE = 1
+    private_constant :STATUS_SUCCESS, :STATUS_FAILURE
+
+    class << self
+      def run!(command)
+        new(command).run!
+      end
+    end
+
+    def initialize(command)
+      @command = command
+    end
+
+    def run!
+      @command.run!
+      STATUS_SUCCESS
+    rescue StandardError => e
+      error { e.backtrace.unshift(e.message).join("\n") }
+      STATUS_FAILURE
+    end
+  end
+end

data/lib/deps_grapher/command/analyzer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  module Command
+    class Analyzer
+      include Logging
+
+      def initialize(file_paths, context)
+        @file_paths = file_paths
+        @context = context
+      end
+
+      def run!
+        if file_paths.empty?
+          warn { "No files to analyze" }
+          return
+        end
+
+        clean_dir!
+        analyze!
+        visualize!
+      rescue TargetNodeNotFound => e
+        info { e.message }
+      end
+
+      private
+
+      attr_reader :file_paths, :context
+
+      def clean_dir!
+        context.clean_dir!
+      end
+
+      def analyze!
+        file_paths.each do |file_path|
+          file_path = File.expand_path file_path
+
+          unless File.exist?(file_path)
+            warn { "Skipping #{file_path}" }
+            next
+          end
+
+          ast_processor = AstProcessor.new(
+            file_path,
+            graph,
+            context.event_processors,
+            context.advanced_const_resolver,
+            context.ignore_errors
+          )
+
+          ast_processor.call
+        end
+      end
+
+      def visualize!
+        writer = context.create_writer
+        visualizer = context.create_visualizer
+        visualizer.accept!(*extract_graph_elements)
+        bytesize = writer.write visualizer.render
+
+        info { "Writing to #{writer.path} (#{bytesize} bytes)" }
+        info { "Run `open #{writer.path}` to view the graph" }
+      end
+
+      def extract_graph_elements
+        if context.target_path
+          source_path_matcher = nil
+          source_path_matcher = Matcher.new(context.source_path) if context.source_path.present?
+
+          target_path_matcher = Matcher.new(context.target_path)
+
+          message = []
+          message << "Searching paths"
+          message << "from `#{source_path_matcher}`" if source_path_matcher
+          message << "to `#{target_path_matcher}`"
+
+          info { message.join(" ") }
+          graph.find_path source_path_matcher, target_path_matcher
+        else
+          [Node.all, Edge.all]
+        end
+      end
+
+      def graph
+        @graph ||= context.create_graph
+      end
+    end
+  end
+end

data/lib/deps_grapher/command/init.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "readline"
+require "fileutils"
+
+module DepsGrapher
+  module Command
+    class Init
+      include Logging
+
+      def initialize(context)
+        @context = context
+      end
+
+      def run!
+        dest = File.expand_path("graphile.rb")
+
+        return if File.exist?(dest) && !ask_yes_no("Overwrite `#{dest}`?")
+
+        context.generate_graphile dest
+
+        info { "\n`#{dest}` was created." }
+        info { "Please edit the configuration file." }
+        info { "Run `bundle exec deps_grapher -c #{File.basename(dest)}`." }
+      end
+
+      private
+
+      attr_reader :context
+
+      def ask_yes_no(question)
+        stty_save = `stty -g`.chomp
+        trap("INT") do
+          system "stty", stty_save
+          exit
+        end
+
+        while (input = Readline.readline("#{question} (y/n): ", true))
+          case input
+          when "y"
+            return true
+          when "n"
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deps_grapher/configuration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class Configuration
+    include PluginDSL
+
+    class_attribute :path
+    class_attribute :root_dir, default: File.expand_path(File.join("..", ".."), __dir__)
+    class_attribute :visualizer
+    class_attribute :visualizer_options, default: { layers: [] }
+    class_attribute :source_path # source class name on graph
+    class_attribute :target_path # target class name on graph
+    class_attribute :clean, default: false
+    class_attribute :logger
+    class_attribute :cache_dir, default: File.expand_path(File.join("..", "..", "tmp", "deps_grapher", "cache"), __dir__)
+    class_attribute :cache_ttl, default: 60 * 5 # 5 minutes
+    class_attribute :output_dir, default: File.expand_path(File.join("..", "..", "tmp", "deps_grapher", "graph"), __dir__)
+    class_attribute :ignore_errors, default: false
+    class_attribute :verbose, default: false
+    class_attribute :dump, default: false
+
+    attr_accessor :layers
+
+    def initialize
+      self.logger = Logger.new($stderr).tap do
+        _1.formatter = ->(_, _, _, msg) { "#{msg}\n" }
+      end
+
+      self.visualizer = Visualizer::Registry.default_visualizer
+
+      @layers = {}
+    end
+
+    def available_visualizers
+      Visualizer::Registry.available_visualizers
+    end
+
+    def load_plugin!
+      PluginLoader.load! plugin_dir
+    end
+
+    def merge!(options)
+      options.each do |key, value|
+        send "#{key}=", value if respond_to?("#{key}=") && !value.nil?
+      end
+    end
+
+    def input
+      @input ||= Input.new(self)
+    end
+
+    def layer(&block)
+      Layer.new(&block).tap do |layer|
+        @layers[layer.name] = layer
+      end
+    end
+
+    def ast_processor_policy(&block)
+      AstProcessorPolicy.new context, &block
+    end
+
+    def plugin_dir(dir = nil)
+      return @plugin_dir unless dir
+
+      @plugin_dir = dir
+    end
+
+    def load!(file)
+      return unless file
+
+      file = File.expand_path file
+      raise ArgumentError, "no such file: #{file}" unless File.exist?(file)
+
+      self.path = file
+
+      content = File.read file
+
+      cache_key = Digest::MD5.hexdigest(content)
+
+      SourceCache::Registry.with_cache cache_key do
+        DSL.new(self).instance_eval content
+      end
+
+      return unless dump
+
+      at_exit do
+        warn ""
+        warn "=============================="
+        warn " Configuration"
+        warn "=============================="
+        puts content
+      end
+    end
+
+    def context
+      @context ||= Context.new self
+    end
+  end
+end

data/lib/deps_grapher/context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module DepsGrapher
+  class Context
+    extend Forwardable
+
+    def_delegators :@config,
+                   :ignore_errors,
+                   :source_path,
+                   :target_path
+
+    attr_accessor :event_processors, :advanced_const_resolver
+
+    def initialize(config)
+      @config = config
+      @event_processors = {}
+    end
+
+    def clean_dir!
+      return unless @config.clean
+
+      FileUtils.rm_rf @config.output_dir
+    end
+
+    def generate_graphile(dest)
+      Graphile::Generator.new(@config).call dest
+    end
+
+    def generate_temp_graphile
+      generate_graphile nil
+    end
+
+    def create_writer
+      HtmlWriter.new @config.output_dir
+    end
+
+    def create_visualizer
+      downloader = Visualizer::Downloader.new @config.output_dir
+      Visualizer.fetch(@config.visualizer).new downloader, @config.visualizer_options
+    end
+
+    def create_graph
+      target_path ? Graph.new : NullGraph.new
+    end
+  end
+end

data/lib/deps_grapher/cytoscape/cose.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../cytoscape"
+
+module DepsGrapher
+  class Cytoscape
+    class Cose < self
+      command_option "cy:cose"
+
+      private
+
+      def required_js
+        super.tap do |js|
+          js << "https://unpkg.com/cose-base/cose-base.js"
+        end
+      end
+
+      def layout_options
+        option = Visualizer::JsOption.new(
+          name: :cose,
+          directed: true,
+          padding: 10,
+          nodeOverlap: 20,
+          refresh: 20,
+          numIter: 1000,
+          initialTemp: 200,
+          coolingFactor: 0.95,
+          minTemp: 1.0
+        )
+        option.add_function(name: :nodeRepulsion, args: :edge, body: "return 100000")
+        option.add_function(name: :idealEdgeLength, args: :edge, body: "return 100")
+        option.add_function(name: :edgeElasticity, args: :edge, body: "return 32")
+      end
+    end
+  end
+end

data/lib/deps_grapher/cytoscape/fcose.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "cose"
+
+module DepsGrapher
+  class Cytoscape
+    class Fcose < Cose
+      command_option "cy:fcose"
+
+      private
+
+      def required_js
+        super.tap do |js|
+          js << "https://unpkg.com/cytoscape-fcose/cytoscape-fcose.js"
+        end
+      end
+
+      def layout_options
+        option = Visualizer::JsOption.new(
+          name: :fcose,
+          directed: true,
+          padding: 10,
+          nodeOverlap: 20,
+          refresh: 20,
+          numIter: 1000,
+          initialTemp: 200,
+          coolingFactor: 0.95,
+          minTemp: 1.0
+        )
+        option.add_function(name: :nodeRepulsion, args: :edge, body: "return 100000")
+        option.add_function(name: :idealEdgeLength, args: :edge, body: "return 100")
+        option.add_function(name: :edgeElasticity, args: :edge, body: "return 32")
+      end
+    end
+  end
+end