blast_radius 0.1.0

data/lib/blast_radius/formatters/html_formatter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'json'
+
+module BlastRadius
+  module Formatters
+    class HtmlFormatter < Base
+      # Format dependency tree as interactive HTML ER diagram
+      # @param root_node [Node] root node of dependency tree
+      # @param options [Hash] formatting options
+      #   - :all_models [Boolean] include all models in ER diagram (default: true)
+      #   - :title [String] custom title
+      #   - :theme [Symbol] :light, :dark, or :auto (default: :auto)
+      # @return [String] HTML representation
+      def format(root_node, options = {})
+        @root_node = root_node
+        @options = options
+        @all_models = discover_all_models
+
+        template_content = File.read(template_path)
+        erb = ERB.new(template_content)
+        erb.result(binding)
+      end
+
+      private
+
+      def template_path
+        File.join(__dir__, '../html/template.html.erb')
+      end
+
+      def css
+        File.read(File.join(__dir__, '../html/styles.css'))
+      end
+
+      def javascript
+        File.read(File.join(__dir__, '../html/graph.js'))
+      end
+
+      def title
+        @options[:title] || 'Dependency Analysis'
+      end
+
+      def root_model
+        @root_node.model_name
+      end
+
+      def total_models
+        @all_models.size
+      end
+
+      def total_associations
+        graph_data[:edges].size
+      end
+
+      def dependent_counts
+        counts = Hash.new(0)
+        graph_data[:edges].each do |edge|
+          counts[edge[:dependent]] += 1 if edge[:dependent]
+        end
+        counts
+      end
+
+      def graph_data
+        @graph_data ||= build_graph_data
+      end
+
+      def build_graph_data
+        nodes = []
+        edges = []
+        visited_edges = Set.new
+
+        # Build nodes from all models
+        @all_models.each do |model_class|
+          nodes << {
+            name: model_class.name,
+            table_name: model_class.table_name
+          }
+
+          # Build edges from all associations
+          analyzer = BlastRadius::Analyzer.new
+          associations = analyzer.analyze(model_class)
+
+          associations.each do |assoc|
+            edge_key = "#{model_class.name}->#{assoc[:class_name]}"
+            next if visited_edges.include?(edge_key)
+
+            edges << {
+              from: model_class.name,
+              to: assoc[:class_name],
+              association: assoc[:name].to_s,
+              dependent: assoc[:dependent].to_s,
+              type: assoc[:type].to_s
+            }
+
+            visited_edges.add(edge_key)
+          end
+        end
+
+        {
+          nodes: nodes,
+          edges: edges
+        }
+      end
+
+      def discover_all_models
+        if defined?(Rails)
+          begin
+            Rails.application.eager_load!
+            ApplicationRecord.descendants.select do |model|
+              model.name.present? && !excluded_model?(model.name)
+            end
+          rescue StandardError
+            # If Rails is not available or ApplicationRecord doesn't exist
+            ActiveRecord::Base.descendants.select do |model|
+              model.name.present? && !excluded_model?(model.name)
+            end
+          end
+        else
+          # For non-Rails environments, use the root model's related models
+          discover_from_tree(@root_node)
+        end
+      end
+
+      def discover_from_tree(node, discovered = Set.new)
+        return discovered.to_a if discovered.include?(node.model_class)
+
+        discovered.add(node.model_class)
+
+        node.children.each do |child|
+          discover_from_tree(child, discovered)
+        end
+
+        discovered.to_a
+      end
+
+      def excluded_model?(model_name)
+        @configuration&.exclude_models&.any? do |pattern|
+          pattern.is_a?(Regexp) ? pattern.match?(model_name) : pattern == model_name
+        end || false
+      end
+    end
+  end
+end

data/lib/blast_radius/formatters/json_formatter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BlastRadius
+  module Formatters
+    class JsonFormatter < Base
+      # Format dependency tree as JSON
+      # @param root_node [Node] root node of dependency tree
+      # @return [String] JSON representation
+      def format(root_node)
+        JSON.pretty_generate(node_to_hash(root_node))
+      end
+
+      private
+
+      def node_to_hash(node)
+        hash = {
+          'model' => node.model_name
+        }
+
+        unless node.root?
+          hash['association'] = node.association_name.to_s
+          hash['type'] = node.association_type.to_s
+          hash['dependent'] = node.dependent_type.to_s
+          hash['through'] = node.through.to_s if node.through
+          hash['polymorphic'] = node.polymorphic if node.polymorphic
+        end
+
+        hash['children'] = node.children.map { |child| node_to_hash(child) } unless node.children.empty?
+
+        hash
+      end
+    end
+  end
+end

data/lib/blast_radius/formatters/mermaid_formatter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BlastRadius
+  module Formatters
+    class MermaidFormatter < Base
+      # Format dependency tree as Mermaid diagram
+      # @param root_node [Node] root node of dependency tree
+      # @return [String] Mermaid diagram syntax
+      def format(root_node)
+        @node_counter = 0
+        @node_ids = {}
+        lines = ['graph TD']
+
+        # Assign ID to root node
+        node_id(root_node)
+
+        # Process all nodes
+        format_node(root_node, lines)
+
+        lines.join("\n")
+      end
+
+      private
+
+      def format_node(node, lines)
+        current_id = node_id(node)
+
+        node.children.each do |child|
+          child_id = node_id(child)
+          association_label = "#{child.association_name}|#{child.dependent_type}"
+
+          # Create edge with label
+          lines << "    #{current_id} -->|#{association_label}| #{child_id}[#{child.model_name}]"
+
+          # Recursively process children
+          format_node(child, lines) unless child.children.empty?
+        end
+      end
+
+      def node_id(node)
+        @node_ids[node] ||= if node.root?
+                              node.model_name
+                            else
+                              "node#{@node_counter += 1}"
+                            end
+      end
+    end
+  end
+end

data/lib/blast_radius/formatters/text_formatter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module BlastRadius
+  module Formatters
+    class TextFormatter < Base
+      TREE_BRANCH = '├── '
+      TREE_LAST = '└── '
+      TREE_VERTICAL = '│   '
+      TREE_SPACE = '    '
+
+      # Format dependency tree as ASCII tree
+      # @param root_node [Node] root node of dependency tree
+      # @return [String] ASCII tree representation
+      def format(root_node)
+        lines = [root_node.model_name]
+        format_children(root_node.children, '', lines)
+        lines.join("\n")
+      end
+
+      private
+
+      def format_children(children, prefix, lines)
+        children.each_with_index do |child, index|
+          is_last = (index == children.size - 1)
+          lines << format_node(child, prefix, is_last)
+
+          unless child.children.empty?
+            new_prefix = prefix + (is_last ? TREE_SPACE : TREE_VERTICAL)
+            format_children(child.children, new_prefix, lines)
+          end
+        end
+      end
+
+      def format_node(node, prefix, is_last)
+        branch = is_last ? TREE_LAST : TREE_BRANCH
+        dependent_label = "[#{node.dependent_type}]"
+        association_label = "#{node.association_name} (#{node.model_name})"
+
+        "#{prefix}#{branch}#{dependent_label} #{association_label}"
+      end
+    end
+  end
+end