lagoon 0.1.0 → 0.2.0

data/lib/lagoon/cli.rb

@@ -1,112 +1,141 @@
 # frozen_string_literal: true
 
-require "thor"
+require 'thor'
 
 module Lagoon
   class CLI < Thor
-    class_option :verbose, type: :boolean, aliases: "-v", desc: "Enable verbose output"
-    class_option :output, type: :string, aliases: "-o", desc: "Output file path"
-    class_option :direction, type: :string, aliases: "-d", desc: "Diagram direction (TB/BT/LR/RL)"
-    class_option :root, type: :string, aliases: "-r", desc: "Application root path"
-
-    desc "models", "Generate Mermaid model diagram"
-    method_option :brief, type: :boolean, aliases: "-b", desc: "Compact diagram (no attributes/methods)"
-    method_option :inheritance, type: :boolean, aliases: "-i", desc: "Include inheritance relationships"
-    method_option :exclude, type: :array, aliases: "-e", desc: "Exclude specified models"
-    method_option :specify, type: :array, aliases: "-s", desc: "Only process specified models"
-    method_option :all_models, type: :boolean, aliases: "-a", desc: "Include all models"
-    method_option :show_belongs_to, type: :boolean, desc: "Show belongs_to associations"
-    method_option :hide_through, type: :boolean, desc: "Hide through associations"
-    method_option :all_columns, type: :boolean, desc: "Show all columns"
-    method_option :hide_magic, type: :boolean, desc: "Hide magic fields (id, timestamps)"
-    method_option :hide_types, type: :boolean, desc: "Hide attribute types"
+    class_option :verbose, type: :boolean, aliases: '-v', desc: 'Enable verbose output'
+    class_option :output, type: :string, aliases: '-o', desc: 'Output file path'
+    class_option :root, type: :string, aliases: '-r', desc: 'Application root path'
+    class_option :strict, type: :boolean, desc: 'Stop on the first analysis error'
+
+    desc 'models', 'Generate Mermaid model diagram'
+    method_option :direction, type: :string, aliases: '-d', desc: 'Diagram direction (TB/BT/LR/RL)'
+    method_option :brief, type: :boolean, aliases: '-b', desc: 'Compact diagram (no attributes/methods)'
+    method_option :inheritance, type: :boolean, aliases: '-i', desc: 'Include inheritance relationships'
+    method_option :exclude, type: :array, aliases: '-e', desc: 'Exclude specified models'
+    method_option :specify, type: :array, aliases: '-s', desc: 'Only process specified models'
+    method_option :all_models, type: :boolean, aliases: '-a', desc: 'Include models outside app/models'
+    method_option :show_belongs_to, type: :boolean, desc: 'Show belongs_to associations'
+    method_option :hide_through, type: :boolean, desc: 'Hide through associations'
+    method_option :all_columns, type: :boolean, desc: 'Show all columns even when --hide-magic is set'
+    method_option :hide_magic, type: :boolean, desc: 'Hide id and timestamp fields'
+    method_option :hide_types, type: :boolean, desc: 'Hide attribute types'
     def models
-      load_rails_environment
-      setup_configuration
-
-      output_file = Lagoon.generate_model_diagram(build_options)
-      say "Model diagram generated: #{output_file}", :green
+      with_rails_environment do
+        report_result('Model', Lagoon.generate_model_diagram(command_options(:model)))
+      end
     end
 
-    desc "controllers", "Generate Mermaid controller diagram"
-    method_option :brief, type: :boolean, aliases: "-b", desc: "Compact diagram (no attributes/methods)"
-    method_option :inheritance, type: :boolean, aliases: "-i", desc: "Include inheritance relationships"
-    method_option :exclude, type: :array, aliases: "-e", desc: "Exclude specified controllers"
-    method_option :specify, type: :array, aliases: "-s", desc: "Only process specified controllers"
-    method_option :hide_public, type: :boolean, desc: "Hide public methods"
-    method_option :hide_protected, type: :boolean, desc: "Hide protected methods"
-    method_option :hide_private, type: :boolean, desc: "Hide private methods"
+    desc 'controllers', 'Generate Mermaid controller diagram'
+    method_option :direction, type: :string, aliases: '-d', desc: 'Diagram direction (TB/BT/LR/RL)'
+    method_option :brief, type: :boolean, aliases: '-b', desc: 'Compact diagram (no methods)'
+    method_option :inheritance, type: :boolean, aliases: '-i', desc: 'Include inheritance relationships'
+    method_option :exclude, type: :array, aliases: '-e', desc: 'Exclude specified controllers'
+    method_option :specify, type: :array, aliases: '-s', desc: 'Only process specified controllers'
+    method_option :all_controllers, type: :boolean, desc: 'Include controllers outside app/controllers'
+    method_option :hide_public, type: :boolean, desc: 'Hide public methods'
+    method_option :hide_protected, type: :boolean, desc: 'Hide protected methods'
+    method_option :hide_private, type: :boolean, desc: 'Hide private methods'
     def controllers
-      load_rails_environment
-      setup_configuration
-
-      output_file = Lagoon.generate_controller_diagram(build_options)
-      say "Controller diagram generated: #{output_file}", :green
+      with_rails_environment do
+        report_result('Controller', Lagoon.generate_controller_diagram(command_options(:controller)))
+      end
     end
 
-    desc "er", "Generate Mermaid ER diagram"
-    method_option :exclude, type: :array, aliases: "-e", desc: "Exclude specified tables"
-    method_option :specify, type: :array, aliases: "-s", desc: "Only process specified tables"
+    desc 'er', 'Generate Mermaid ER diagram'
+    method_option :exclude, type: :array, aliases: '-e', desc: 'Exclude specified tables'
+    method_option :specify, type: :array, aliases: '-s', desc: 'Only process specified tables'
     def er
-      load_rails_environment
-      setup_configuration
+      with_rails_environment do
+        report_result('ER', Lagoon.generate_er_diagram(command_options(:er)))
+      end
+    end
 
-      output_file = Lagoon.generate_er_diagram(build_options)
-      say "ER diagram generated: #{output_file}", :green
+    desc 'controller_models', 'Generate controller-model dependency diagram'
+    method_option :direction, type: :string, aliases: '-d', desc: 'Diagram direction (TB/BT/LR/RL)'
+    method_option :exclude, type: :array, aliases: '-e', desc: 'Exclude specified controllers'
+    method_option :specify, type: :array, aliases: '-s', desc: 'Only process specified controllers'
+    method_option :all_controllers, type: :boolean, desc: 'Include controllers outside app/controllers'
+    method_option :show_actions, type: :boolean, default: true, desc: 'Show action names in labels'
+    def controller_models
+      with_rails_environment do
+        result = Lagoon.generate_controller_model_diagram(command_options(:controller_model))
+        report_result('Controller-model', result)
+      end
     end
 
-    desc "all", "Generate all diagrams"
-    method_option :brief, type: :boolean, aliases: "-b", desc: "Compact diagrams (no attributes/methods)"
+    desc 'all', 'Generate all diagrams'
+    method_option :direction, type: :string, aliases: '-d', desc: 'Class diagram direction (TB/BT/LR/RL)'
+    method_option :brief, type: :boolean, aliases: '-b', desc: 'Compact class diagrams'
     def all
-      load_rails_environment
-      setup_configuration
-
-      results = Lagoon.generate_all(build_options)
-      say "All diagrams generated:", :green
-      say "  Models: #{results[:models]}", :green
-      say "  Controllers: #{results[:controllers]}", :green
-      say "  ER: #{results[:er]}", :green
+      with_rails_environment do
+        results = Lagoon.generate_all(all_options)
+        say 'All diagrams generated:', :green
+        results.each do |name, result|
+          say "  #{name}: #{result.path}", :green
+          report_warnings(result)
+        end
+      end
     end
 
-    desc "version", "Show version"
+    desc 'version', 'Show version'
     def version
       say "Lagoon version #{Lagoon::VERSION}"
     end
 
-    private
+    def self.exit_on_failure?
+      true
+    end
 
-    def load_rails_environment
-      rails_root = options[:root] || Dir.pwd
+    no_commands do
+      private
+
+      def with_rails_environment
+        rails_root = File.expand_path(options[:root] || Dir.pwd)
+        environment_file = File.join(rails_root, 'config', 'environment.rb')
+        unless File.file?(environment_file)
+          raise Thor::Error,
+                'Rails application not found. Run from a Rails root or pass --root.'
+        end
+
+        Dir.chdir(rails_root) do
+          require environment_file
+          yield
+        end
+      rescue Thor::Error
+        raise
+      rescue LoadError, StandardError => e
+        message = "#{e.class}: #{e.message}"
+        message += "\n#{e.backtrace.join("\n")}" if options[:verbose] && e.backtrace
+        raise Thor::Error, message
+      end
 
-      unless File.exist?(File.join(rails_root, "config", "environment.rb"))
-        say "Error: Rails application not found. Please run from Rails root or use --root option.", :red
-        exit 1
+      def command_options(kind)
+        raw_options.slice(*Options.allowed_keys(kind))
       end
 
-      Dir.chdir(rails_root)
-      require File.expand_path("config/environment", rails_root)
-    rescue LoadError => e
-      say "Error loading Rails environment: #{e.message}", :red
-      exit 1
-    end
+      def all_options
+        allowed = Options::KEYS.values.flatten.uniq
+        raw_options.slice(*allowed)
+      end
 
-    def setup_configuration
-      Lagoon.configure do |config|
-        config.diagram_direction = options[:direction] if options[:direction]
-        config.show_attributes = !options[:brief] if options.key?(:brief)
-        config.show_methods = !options[:brief] if options.key?(:brief)
-        config.include_inheritance = options[:inheritance] if options.key?(:inheritance)
-        config.exclude_models = options[:exclude] if options[:exclude]
+      def raw_options
+        options.to_h.transform_keys(&:to_sym).reject do |key, value|
+          key == :root || value.nil?
+        end
       end
-    end
 
-    def build_options
-      opts = options.dup
-      opts[:show_belongs_to] = true if opts[:show_belongs_to]
-      opts[:hide_through] = true if opts[:hide_through]
-      opts[:all_columns] = true if opts[:all_columns]
-      opts[:hide_magic] = true if opts[:hide_magic]
-      opts
+      def report_result(label, result)
+        say "#{label} diagram generated: #{result.path}", :green
+        report_warnings(result)
+      end
+
+      def report_warnings(result)
+        return unless options[:verbose]
+
+        result.warnings.each { |warning| say "  Warning: #{warning}", :yellow }
+      end
     end
   end
 end

data/lib/lagoon/configuration.rb

@@ -2,19 +2,55 @@
 
 module Lagoon
   class Configuration
-    attr_accessor :output_dir, :diagram_direction, :show_attributes,
-                  :show_methods, :include_inheritance, :exclude_models,
-                  :exclude_controllers, :diagram_format
+    DIRECTIONS = %w[TB BT LR RL].freeze
+
+    attr_accessor :show_attributes, :show_methods, :include_inheritance,
+                  :exclude_models, :exclude_controllers, :exclude_tables,
+                  :internal_tables, :include_framework_bases, :strict,
+                  :helper_models
+    attr_reader :output_dir, :diagram_direction
 
     def initialize
-      @output_dir = "doc/diagrams"
-      @diagram_direction = "TB"
+      self.output_dir = 'doc/diagrams'
+      self.diagram_direction = 'TB'
       @show_attributes = true
       @show_methods = false
       @include_inheritance = true
       @exclude_models = []
       @exclude_controllers = []
-      @diagram_format = :class_diagram # or :er_diagram
+      @exclude_tables = []
+      @internal_tables = %w[schema_migrations ar_internal_metadata]
+      @include_framework_bases = false
+      @strict = false
+      @helper_models = { 'current_user' => 'User' }
+    end
+
+    def output_dir=(value)
+      path = value.to_s
+      raise ConfigurationError, 'Output directory cannot be empty' if path.empty?
+
+      @output_dir = path
+    end
+
+    def diagram_direction=(value)
+      @diagram_direction = self.class.validate_direction!(value)
+    end
+
+    def self.validate_direction!(value)
+      direction = value.to_s.upcase
+      return direction if DIRECTIONS.include?(direction)
+
+      raise ConfigurationError,
+            "Invalid diagram direction #{value.inspect}; expected one of #{DIRECTIONS.join(', ')}"
+    end
+
+    def initialize_copy(original)
+      super
+      @exclude_models = original.exclude_models.dup
+      @exclude_controllers = original.exclude_controllers.dup
+      @exclude_tables = original.exclude_tables.dup
+      @internal_tables = original.internal_tables.dup
+      @helper_models = original.helper_models.dup
     end
   end
 end

data/lib/lagoon/diagram/base.rb

@@ -1,37 +1,77 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+require 'tempfile'
+
 module Lagoon
   module Diagram
     class Base
       attr_reader :options, :config
 
-      def initialize(options = {})
-        @options = options
-        @config = Lagoon.configuration
+      def initialize(options = nil, configuration: Lagoon.configuration.dup, **keyword_options)
+        @config = configuration
+        raw_options = (options || {}).to_h.merge(keyword_options)
+        @options = Options.for(diagram_kind, raw_options, config: @config)
       end
 
       def generate
-        raise NotImplementedError, "Subclasses must implement #generate"
+        parsed_data = parser.parse
+        content = renderer.render(parsed_data)
+        path = write_to_file(content)
+        Result.new(
+          path: path,
+          content: content,
+          warnings: parsed_data.fetch(:warnings, []),
+          counts: parsed_data.fetch(:counts, infer_counts(parsed_data))
+        )
       end
 
       protected
 
       def output_path
-        @output_path ||= File.join(@config.output_dir, default_filename)
+        @output_path ||= @options[:output] || File.join(@config.output_dir, default_filename)
+      end
+
+      def diagram_kind
+        raise NotImplementedError, 'Subclasses must implement #diagram_kind'
+      end
+
+      def parser
+        raise NotImplementedError, 'Subclasses must implement #parser'
+      end
+
+      def renderer
+        raise NotImplementedError, 'Subclasses must implement #renderer'
       end
 
       def default_filename
-        raise NotImplementedError, "Subclasses must implement #default_filename"
+        raise NotImplementedError, 'Subclasses must implement #default_filename'
       end
 
       def ensure_output_directory
-        FileUtils.mkdir_p(@config.output_dir)
+        FileUtils.mkdir_p(File.dirname(output_path))
       end
 
       def write_to_file(content)
         ensure_output_directory
-        File.write(output_path, content)
+        Tempfile.create(['.lagoon', '.tmp'], File.dirname(output_path)) do |file|
+          file.write(content)
+          file.flush
+          file.fsync
+          file.close
+          File.rename(file.path, output_path)
+        end
         output_path
+      rescue SystemCallError => e
+        raise OutputError, "Failed to write #{output_path}: #{e.message}"
+      end
+
+      def infer_counts(parsed_data)
+        {
+          classes: parsed_data.fetch(:classes, []).size,
+          entities: parsed_data.fetch(:entities, []).size,
+          relationships: parsed_data.fetch(:relationships, []).size
+        }.reject { |_key, count| count.zero? }
       end
     end
   end

data/lib/lagoon/diagram/controller_diagram.rb

@@ -1,30 +1,24 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module Lagoon
   module Diagram
     class ControllerDiagram < Base
-      def generate
-        parser = Parser::ControllerParser.new(@options)
-        parsed_data = parser.parse
-
-        renderer = Renderer::ClassDiagramRenderer.new(
-          direction: @options[:direction] || @config.diagram_direction
-        )
-        content = renderer.render(parsed_data)
+      protected
 
-        output_file = @options[:output] || output_path
-        ensure_output_directory
-        File.write(output_file, content)
+      def diagram_kind
+        :controller
+      end
 
-        output_file
+      def parser
+        @parser ||= Parser::ControllerParser.new(@options)
       end
 
-      protected
+      def renderer
+        @renderer ||= Renderer::ClassDiagramRenderer.new(direction: @options[:direction])
+      end
 
       def default_filename
-        "controllers.mermaid"
+        'controllers.mermaid'
       end
     end
   end

data/lib/lagoon/diagram/controller_model_diagram.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Diagram
+    class ControllerModelDiagram < Base
+      protected
+
+      def diagram_kind
+        :controller_model
+      end
+
+      def parser
+        @parser ||= Parser::ControllerModelParser.new(@options)
+      end
+
+      def renderer
+        @renderer ||= Renderer::ControllerModelErRenderer.new(
+          direction: @options[:direction],
+          show_actions: @options[:show_actions]
+        )
+      end
+
+      def default_filename
+        'controller_models.mermaid'
+      end
+    end
+  end
+end

data/lib/lagoon/diagram/er_diagram.rb

@@ -1,30 +1,24 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module Lagoon
   module Diagram
     class ErDiagram < Base
-      def generate
-        parser = Parser::SchemaParser.new(@options)
-        parsed_data = parser.parse
-
-        renderer = Renderer::ErDiagramRenderer.new(
-          direction: @options[:direction] || @config.diagram_direction
-        )
-        content = renderer.render(parsed_data)
+      protected
 
-        output_file = @options[:output] || output_path
-        ensure_output_directory
-        File.write(output_file, content)
+      def diagram_kind
+        :er
+      end
 
-        output_file
+      def parser
+        @parser ||= Parser::SchemaParser.new(@options)
       end
 
-      protected
+      def renderer
+        @renderer ||= Renderer::ErDiagramRenderer.new
+      end
 
       def default_filename
-        "er_diagram.mermaid"
+        'er_diagram.mermaid'
       end
     end
   end

data/lib/lagoon/diagram/model_diagram.rb

@@ -1,30 +1,27 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module Lagoon
   module Diagram
     class ModelDiagram < Base
-      def generate
-        parser = Parser::ModelParser.new(@options)
-        parsed_data = parser.parse
-
-        renderer = Renderer::ClassDiagramRenderer.new(
-          direction: @options[:direction] || @config.diagram_direction
-        )
-        content = renderer.render(parsed_data)
+      protected
 
-        output_file = @options[:output] || output_path
-        ensure_output_directory
-        File.write(output_file, content)
+      def diagram_kind
+        :model
+      end
 
-        output_file
+      def parser
+        @parser ||= Parser::ModelParser.new(@options)
       end
 
-      protected
+      def renderer
+        @renderer ||= Renderer::ClassDiagramRenderer.new(
+          direction: @options[:direction],
+          show_types: !@options[:hide_types]
+        )
+      end
 
       def default_filename
-        "models.mermaid"
+        'models.mermaid'
       end
     end
   end

data/lib/lagoon/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lagoon
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class RailsLoadError < Error; end
+  class ParseError < Error; end
+  class OutputError < Error; end
+end