tng 0.1.6 → 0.2.1

data/lib/tng/services/direct_generation.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require_relative "extract_methods"
+
+module Tng
+  module Services
+    class DirectGeneration
+      include ExtractMethods
+
+      def initialize(pastel, testng, http_client, params, show_post_generation_menu_proc)
+        @pastel = pastel
+        @testng = testng
+        @http_client = http_client
+        @params = params
+        @show_post_generation_menu = show_post_generation_menu_proc
+      end
+
+      def run
+        type = normalize_type(@params[:type])
+        file_name = @params[:file]
+        method_name = @params[:method]
+
+        unless type && file_name && method_name
+          puts @pastel.red("❌ All parameters are required for direct generation: --type, --file, --method")
+          puts @pastel.yellow("Usage: bundle exec tng --type=controller --file=users --method=index")
+          puts @pastel.yellow("Shortcuts: bundle exec tng -t=c -f=users -m=index")
+          return
+        end
+
+        unless %w[controller model service other].include?(type)
+          puts @pastel.red("❌ Invalid type: #{@params[:type]}")
+          puts @pastel.yellow("Supported types: controller, model, service, other")
+          return
+        end
+
+        case type
+        when "controller"
+          run_controller_method_generation(file_name, method_name)
+        when "model"
+          run_model_method_generation(file_name, method_name)
+        when "service"
+          run_service_method_generation(file_name, method_name)
+        when "other"
+          run_other_method_generation(file_name, method_name)
+        end
+      end
+
+      def normalize_type(type_param)
+        case type_param&.downcase
+        when "c", "controller"
+          "controller"
+        when "m", "mo", "model"
+          "model"
+        when "s", "se", "service"
+          "service"
+        when "o", "other"
+          "other"
+        else
+          type_param&.downcase
+        end
+      end
+
+      def run_controller_method_generation(file_name, method_name)
+        controllers = Tng::Analyzers::Controller.files_in_dir("app/controllers").map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/controllers/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        controller = find_matching_controller(controllers, file_name)
+
+        unless controller
+          puts @pastel.red("❌ Controller not found: #{file_name}")
+          puts @pastel.yellow("Available controllers:")
+          controllers.first(5).each do |ctrl|
+            puts @pastel.dim("  - #{ctrl[:name]}")
+          end
+          puts @pastel.dim("  ... and #{controllers.length - 5} more") if controllers.length > 5
+          return
+        end
+
+        methods = extract_controller_methods(controller)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{controller[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{controller[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{controller[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_controller_method(controller, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_controller(controllers, file_name)
+        controllers.find do |controller|
+          controller[:name].downcase == file_name.downcase ||
+            controller[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").gsub("_controller", "").downcase == file_name.downcase ||
+            File.basename(controller[:path], ".rb").downcase == "#{file_name}_controller".downcase
+        end
+      end
+
+      def run_model_method_generation(file_name, method_name)
+        models = Tng::Analyzers::Model.files_in_dir("app/models").map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/models/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        model = find_matching_model(models, file_name)
+
+        unless model
+          puts @pastel.red("❌ Model not found: #{file_name}")
+          puts @pastel.yellow("Available models:")
+          models.first(5).each do |mdl|
+            puts @pastel.dim("  - #{mdl[:name]}")
+          end
+          puts @pastel.dim("  ... and #{models.length - 5} more") if models.length > 5
+          return
+        end
+
+        methods = extract_model_methods(model)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{model[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{model[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{model[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_model_method(model, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_model(models, file_name)
+        models.find do |model|
+          model[:name].downcase == file_name.downcase ||
+            model[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(model[:path], ".rb").downcase == file_name.downcase
+        end
+      end
+
+      def run_service_method_generation(file_name, method_name)
+        services = Tng::Analyzers::Service.files_in_dir.map do |file|
+          relative_path = file[:path].gsub(%r{^.*app/services?/}, "").gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path]
+          }
+        end
+
+        service = find_matching_service(services, file_name)
+
+        unless service
+          puts @pastel.red("❌ Service not found: #{file_name}")
+          puts @pastel.yellow("Available services:")
+          services.first(5).each do |svc|
+            puts @pastel.dim("  - #{svc[:name]}")
+          end
+          puts @pastel.dim("  ... and #{services.length - 5} more") if services.length > 5
+          return
+        end
+
+        methods = extract_service_methods(service)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{service[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{service[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{service[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_service_method(service, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_service(services, file_name)
+        services.find do |service|
+          service[:name].downcase == file_name.downcase ||
+            service[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(service[:path], ".rb").downcase == file_name.downcase
+        end
+      end
+
+      def run_other_method_generation(file_name, method_name)
+        other_files = Tng::Analyzers::Other.files_in_dir.map do |file|
+          relative_path = file[:relative_path].gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+          {
+            name: namespaced_name,
+            path: file[:path],
+            type: file[:type]
+          }
+        end
+
+        other_file = find_matching_other_file(other_files, file_name)
+
+        unless other_file
+          puts @pastel.red("❌ Other file not found: #{file_name}")
+          puts @pastel.yellow("Available other files:")
+          other_files.first(5).each do |file|
+            puts @pastel.dim("  - #{file[:name]}")
+          end
+          puts @pastel.dim("  ... and #{other_files.length - 5} more") if other_files.length > 5
+          return
+        end
+
+        methods = extract_other_methods(other_file)
+
+        if methods.empty?
+          puts @pastel.yellow("⚠️  No methods found in #{other_file[:name]}")
+          return
+        end
+
+        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+
+        unless method_info
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{other_file[:name]}")
+          puts @pastel.yellow("Available methods:")
+          methods.first(10).each do |method|
+            puts @pastel.dim("  - #{method[:name]}")
+          end
+          puts @pastel.dim("  ... and #{methods.length - 10} more") if methods.length > 10
+          return
+        end
+
+        puts @pastel.bright_white("🎯 Generating test for #{other_file[:name]}##{method_info[:name]}...")
+
+        result = Tng::Services::TestGenerator.new(@http_client).run_for_other_method(other_file, method_info)
+
+        if result && result[:file_path]
+          @show_post_generation_menu.call(result)
+        else
+          puts @pastel.red("❌ Failed to generate test")
+        end
+      end
+
+      def find_matching_other_file(other_files, file_name)
+        other_files.find do |file|
+          file[:name].downcase == file_name.downcase ||
+            file[:name].split("::").last.downcase == file_name.downcase ||
+            File.basename(file[:path], ".rb").downcase == file_name.downcase ||
+            normalize_other_file_path(file[:path]).downcase == file_name.downcase
+        end
+      end
+
+      def normalize_other_file_path(file_path)
+        Tng::Analyzers::Other::OTHER_DIRECTORIES.each do |dir|
+          pattern = %r{^.*/#{Regexp.escape(dir)}/}
+          return file_path.gsub(pattern, "").gsub(".rb", "") if file_path.match?(pattern)
+        end
+        file_path # fallback if no match
+      end
+    end
+  end
+end

data/lib/tng/services/extract_methods.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Tng
+  module Services
+    module ExtractMethods
+      def extract_controller_methods(controller)
+        methods = Tng::Analyzers::Controller.methods_for_controller(controller[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing controller: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_model_methods(model)
+        methods = Tng::Analyzers::Model.methods_for_model(model[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing model: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_service_methods(service)
+        methods = Tng::Analyzers::Service.methods_for_service(service[:name])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing service: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+
+      def extract_other_methods(other_file)
+        methods = Tng::Analyzers::Other.methods_for_other(other_file[:name], other_file[:path])
+        Array(methods)
+      rescue StandardError => e
+        puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing file: #{e.message}", Tng::UI::Theme.color(:error)))
+        []
+      end
+    end
+  end
+end