deps_grapher 1.0.0

data/lib/deps_grapher/layer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "layer/registry"
+require_relative "visualizer/color"
+
+module DepsGrapher
+  class Layer
+    class << self
+      def fetch(file_path)
+        Registry.fetch file_path
+      end
+
+      def names
+        Registry.all.to_set(&:name)
+      end
+
+      def visible_names
+        Registry.all.select(&:visible).to_set(&:name)
+      end
+
+      def exist?(file_path)
+        Registry.exist? file_path
+      end
+    end
+
+    attr_accessor :name, :visible
+
+    def initialize(&block)
+      @visible = true
+      DSL.new(self).instance_eval(&block)
+
+      assert!
+
+      return if default?
+
+      source.files.each do |file|
+        Registry.register file, self
+      end
+
+      SourceCache.register! name, source
+    end
+
+    def source(&block)
+      @source_defined = true if block
+      @source ||= Source.new(name, &block)
+    end
+
+    def color(&block)
+      @color_defined = true if block
+      Visualizer::Color.new(name, &block)
+    end
+
+    private
+
+    def assert!
+      raise ArgumentError, "layer: no `name` given" unless name
+      raise ArgumentError, "layer `#{name}` has no `source` block" unless default? || @source_defined
+      raise ArgumentError, "layer `#{name}` has no `color` block" unless @color_defined
+    end
+
+    def default?
+      name == :__default
+    end
+
+    Default = (new do
+      name :__default
+      visible true
+      color do
+        background "#BDBDBD"
+        border "#9E9E9E"
+        font "#BDBDBD"
+      end
+    end).freeze
+  end
+end

data/lib/deps_grapher/logging.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  module Logging
+    def info(&block)
+      DepsGrapher.logger.info(&block)
+    end
+
+    def warn(&block)
+      DepsGrapher.logger.warn(&block)
+    end
+
+    def error(&block)
+      DepsGrapher.logger.error(&block)
+    end
+
+    def verbose(&block)
+      DepsGrapher.logger.info(&block) if DepsGrapher.config.verbose
+    end
+  end
+end

data/lib/deps_grapher/matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class Matcher
+    def initialize(pattern)
+      @regexp = convert_to_regexp pattern
+    end
+
+    def match?(value)
+      @regexp.match? value
+    end
+
+    def to_s
+      @regexp.inspect
+    end
+    alias inspect to_s
+
+    private
+
+    def convert_to_regexp(pattern)
+      if pattern.is_a?(Regexp)
+        pattern
+      else
+        Regexp.new("\\A#{pattern.gsub(/\.?\*/, ".*")}\\z")
+      end
+    end
+  end
+end

data/lib/deps_grapher/node.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class Node
+    class << self
+      def guid
+        @guid ||= 0
+        @guid += 1
+      end
+
+      def fetch(class_name)
+        registry[class_name]
+      end
+
+      def add(class_name, location)
+        return nil if class_name.nil? || location.nil?
+
+        registry[class_name] ||= new class_name, location
+      end
+
+      def all
+        registry.values
+      end
+
+      private
+
+      def registry
+        @registry ||= {}
+      end
+    end
+
+    private_class_method :new
+
+    attr_accessor :id, :class_name, :location, :parent, :deps_count
+
+    def initialize(class_name, location)
+      @id = "n#{self.class.guid}"
+      @class_name = class_name
+      @location = location
+      @parent = nil
+      @deps_count = 0
+    end
+
+    def label
+      deps_count.positive? ? "#{class_name} (#{deps_count})" : class_name
+    end
+
+    def layer
+      @layer ||= Layer.fetch(location).name
+    end
+
+    def increment_deps_count!
+      @deps_count += 1
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && id == other.id
+    end
+    alias == eql?
+
+    def hash
+      id.hash
+    end
+  end
+end

data/lib/deps_grapher/plugin_dsl.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  module PluginDSL
+    def with_plugin(&block)
+      plugin_dir = DepsGrapher.config.plugin_dir
+      return if plugin_dir.blank? || !File.directory?(plugin_dir)
+
+      block.call plugin_dir
+    end
+  end
+end

data/lib/deps_grapher/plugin_loader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class PluginLoader
+    class << self
+      def load!(plugin_dir)
+        new(plugin_dir).load!
+      end
+    end
+
+    private_class_method :new
+
+    def initialize(plugin_dir)
+      @plugin_dir = plugin_dir
+    end
+
+    def load!
+      return if plugin_dir.blank? || !Dir.exist?(plugin_dir)
+
+      Dir.glob(File.join(plugin_dir, "**", "*.rb")).sort.each do |file|
+        require file
+      end
+    end
+
+    private
+
+    attr_reader :plugin_dir
+  end
+end

data/lib/deps_grapher/source.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class Source
+    attr_accessor :root, :glob_pattern
+
+    def initialize(name, &block)
+      @name = name
+      @include_pattern = nil
+      @exclude_pattern = nil
+
+      DSL.new(self).instance_eval(&block)
+
+      assert!
+
+      @glob_pattern = Array(glob_pattern.presence || File.join("**", "*.rb")).each_with_object([]) do |pattern, array|
+        array << File.join(root, pattern)
+      end
+    end
+
+    def files
+      Dir.glob(glob_pattern).sort.uniq.each_with_object([]) do |file, files|
+        next if include_pattern && !include_pattern.match?(file)
+        next if exclude_pattern&.match?(file)
+
+        files << file
+      end
+    end
+
+    def include_pattern=(pattern)
+      @include_pattern = Matcher.new pattern
+    end
+
+    def exclude_pattern=(pattern)
+      @exclude_pattern = Matcher.new pattern
+    end
+
+    def to_s
+      "glob_pattern: #{glob_pattern.inspect}, include_pattern: #{include_pattern.inspect}, exclude_pattern: #{exclude_pattern.inspect}"
+    end
+
+    private
+
+    attr_reader :include_pattern, :exclude_pattern
+
+    def assert!
+      raise ArgumentError, "source: no `root` given" if root.blank?
+      raise ArgumentError, "source: directory not found `#{root}`" unless Dir.exist?(root)
+    end
+  end
+end

data/lib/deps_grapher/source_cache/class_name_extractor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class SourceCache
+    class ClassNameExtractor < Parser::AST::Processor
+      class << self
+        def cache
+          @cache ||= Set.new
+        end
+      end
+
+      def initialize(&block)
+        super()
+        @block = block
+      end
+
+      def extract!(file_path)
+        source_buffer = Parser::Source::Buffer.new(file_path)
+        parser = Parser::CurrentRuby.new
+        process parser.parse(source_buffer.read)
+      end
+
+      def on_module(node)
+        const_node = node.children[0]
+        name = extract_const_name const_node
+
+        @namespace_stack ||= []
+        @namespace_stack.push name
+
+        super
+
+        const_name = @namespace_stack.join("::")
+
+        unless self.class.cache.include? const_name
+          self.class.cache << const_name
+          @block.call const_name, node.location.name.source_buffer.name
+        end
+
+        @namespace_stack.pop
+      end
+      alias on_class on_module
+
+      private
+
+      def extract_const_name(node)
+        case node.type
+        when :const
+          base, name = *node
+          if base.nil?
+            name.to_s
+          else
+            [extract_const_name(base), name].compact.join "::"
+          end
+        else
+          raise "unexpected node type: #{node.type}"
+        end
+      end
+    end
+  end
+end

data/lib/deps_grapher/source_cache/registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class SourceCache
+    module Registry
+      class << self
+        def fetch(name)
+          registry.fetch name
+        rescue KeyError
+          raise SourceCacheNotFound, "source cache not found: #{name}"
+        end
+        alias [] fetch
+
+        def key?(name)
+          registry.key? name
+        end
+
+        def register(by_const_name, by_location)
+          by_const_name.each do |const_name, location|
+            registry[const_name] ||= location
+          end
+
+          by_location.each do |location, const_name|
+            registry[location] ||= const_name
+          end
+        end
+
+        def with_cache(key)
+          restore_cache! key
+          yield
+          persist_cache! key
+        end
+
+        def persist_cache!(key)
+          cache_file = DepsGrapher.cache_file key
+          cache_file.write @registry
+        end
+
+        def restore_cache!(key)
+          cache_file = DepsGrapher.cache_file key
+          loaded = cache_file.read
+
+          unless loaded
+            @restored_cache = false
+            return
+          end
+
+          @registry = loaded
+          @restored_cache = true
+        end
+
+        def restored_cache?
+          @restored_cache
+        end
+
+        private
+
+        def registry
+          @registry ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/deps_grapher/source_cache.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  class SourceCache
+    include Logging
+
+    class << self
+      def register!(name, source)
+        new(name, source).register!
+      end
+    end
+
+    attr_reader :root
+
+    def initialize(name, source)
+      @name = name
+      @source = source
+      @root = @source.root
+      @cache_by_const_name = {}
+      @cache_by_location = {}
+    end
+
+    def register!
+      return if Registry.restored_cache?
+
+      class_name_extractor = ClassNameExtractor.new do |class_name, location|
+        @cache_by_const_name[class_name] = location
+        @cache_by_location[location] ||= class_name
+      end
+
+      verbose { "Collecting `#{@name}` layer by #{@source}" }
+
+      start = Time.now
+
+      @source.files.each do |file|
+        class_name_extractor.extract! file
+      end
+
+      info do
+        "Found #{@cache_by_const_name.size} modules/classes, #{@cache_by_location.size} locations in `#{@name}` layer (#{Time.now - start} sec)"
+      end
+      verbose { "" }
+
+      Registry.register @cache_by_const_name, @cache_by_location
+
+      ClassNameExtractor.cache.clear
+    end
+  end
+end

data/lib/deps_grapher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DepsGrapher
+  VERSION = "1.0.0"
+end

data/lib/deps_grapher/vis/box.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../vis"
+
+module DepsGrapher
+  class Vis
+    class Box < self
+      command_option "vis:box"
+
+      private
+
+      def font_color(_)
+        "#fff"
+      end
+
+      def shape
+        :box
+      end
+    end
+  end
+end

data/lib/deps_grapher/vis/dot.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../vis"
+
+module DepsGrapher
+  class Vis
+    class Dot < self
+      command_option "vis:dot"
+
+      private
+
+      def shape
+        :dot
+      end
+    end
+  end
+end

data/lib/deps_grapher/vis/template.erb

@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Network vis <%= shape %></title>
+    <meta name=”viewport” content=”width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no″>
+    <meta charset="utf-8">
+    <style>
+      #network {
+        width:  100vw;
+        height: 100vh;
+      }
+    </style>
+    <% required_js.each do |js| -%>
+    <script src="<%= File.basename js %>"></script>
+    <% end -%>
+  </head>
+  <body>
+    <div id="network"></div>
+    <script>
+      const json = <%= data.to_json %>;
+      const nodes = new vis.DataSet(json['nodes']);
+      const edges = new vis.DataSet(json['edges']);
+      const container = document.getElementById('network');
+      const data = {
+        nodes: nodes,
+        edges: edges
+      };
+      const options = {
+        layout: {
+          improvedLayout: false
+        },
+      };
+      const network = new vis.Network(container, data, options);
+    </script>
+  </body>
+</html>

data/lib/deps_grapher/vis.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "visualizer/base"
+
+module DepsGrapher
+  class Vis < Visualizer::Base
+    private
+
+    def required_js
+      ["https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"]
+    end
+
+    def template_path
+      File.expand_path File.join("vis", "template.erb"), __dir__
+    end
+
+    def shape
+      raise NotImplementedError
+    end
+
+    def data
+      nodes = @nodes.each_with_object([]) do |node, array|
+        next if skip_node?(node)
+
+        array << convert_node(node)
+      end
+
+      edges = @edges.each_with_object([]) do |edge, array|
+        next if skip_edge?(edge)
+
+        array << convert_edge(edge)
+      end
+
+      { nodes: nodes, edges: edges }
+    end
+
+    def convert_node(node)
+      root_node = node.parent.nil?
+
+      {
+        id: node.id,
+        label: node.label,
+        shape: shape,
+        size: (root_node ? 10 : 5) + [1.5 * node.deps_count, 20].min,
+        font: {
+          size: (root_node ? 8 : 5) + [1.2 * node.deps_count, 5].min,
+          color: font_color(node.layer)
+        },
+        color: color_settings(node.layer).except(:font)
+      }
+    end
+
+    def convert_edge(edge)
+      {
+        from: edge.from.id,
+        to: edge.to.id,
+        arrows: :to
+      }
+    end
+
+    def skip_node?(node)
+      options[:layers].present? && !options[:layers].include?(node.layer)
+    end
+
+    def skip_edge?(edge)
+      skip_node?(edge.to)
+    end
+  end
+end

data/lib/deps_grapher/visualizer/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+require_relative "command_option"
+require_relative "color"
+
+module DepsGrapher
+  module Visualizer
+    class Base
+      class << self
+        def command_option(name, default: false)
+          Registry.register self, CommandOption.new(name, default)
+        end
+      end
+
+      attr_reader :options
+
+      def initialize(downloader, options)
+        @downloader = downloader
+        @options = options
+        @nodes = []
+        @edges = []
+      end
+
+      def accept!(nodes, edges)
+        @nodes = nodes
+        @edges = edges
+        self
+      end
+
+      def render
+        required_js.each do |url|
+          @downloader.download url
+        end
+
+        ERB.new(File.read(template_path), trim_mode: "-").result(binding)
+      end
+
+      private
+
+      def required_js
+        []
+      end
+
+      def template_path
+        raise NotImplementedError
+      end
+
+      def color(layer_name)
+        Color[layer_name]
+      end
+
+      def color_map(type)
+        Color.generate_map(type)
+      end
+
+      def arrow_color(layer_name)
+        color(layer_name).arrow || background_color(layer_name)
+      end
+
+      def background_color(layer_name)
+        color(layer_name).background
+      end
+
+      def font_color(layer_name)
+        color(layer_name).font
+      end
+
+      def color_settings(layer_name)
+        color(layer_name).settings
+      end
+    end
+  end
+end