tng 0.2.3 → 0.2.4

data/lib/tng/services/direct_generation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "extract_methods"
+require_relative "file_type_detector"
 
 module Tng
   module Services
@@ -16,281 +17,79 @@ module Tng
       end
 
       def run
-        type = normalize_type(@params[:type])
-        file_name = @params[:file]
-        method_name = @params[:method]
+        file_path, method_name = @params[:file], @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")
+        unless file_path && method_name
+          puts @pastel.red("❌ Both file and method parameters are required")
+          puts @pastel.yellow("Usage: bundle exec tng app/controllers/users_controller.rb index")
+          puts @pastel.yellow("   or: bundle exec tng --file=users_controller.rb --method=index")
+          puts @pastel.yellow("   or: bundle exec tng f=users_controller.rb 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
+        resolved_path = FileTypeDetector.resolve_file_path(file_path)
 
-        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
+        unless resolved_path && File.exist?(resolved_path)
+          puts @pastel.red("❌ File not found: #{file_path}")
+          suggest_similar_files(file_path)
           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
+        type = FileTypeDetector.detect_type(resolved_path)
+        generate_test_for_file(resolved_path, method_name, type)
       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("::")
+      private
 
-          {
-            name: namespaced_name,
-            path: file[:path]
-          }
-        end
+      def suggest_similar_files(file_path)
+        base_name = File.basename(file_path, '.rb')
+        puts @pastel.yellow("💡 Did you mean one of these?")
 
-        model = find_matching_model(models, file_name)
+        similar_files = find_similar_files(base_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)
+        if similar_files.empty?
+          puts @pastel.dim("  No similar files found")
         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
+          similar_files.first(5).each { |file| puts @pastel.dim("  • #{file}") }
         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("::")
+      def find_similar_files(base_name)
+        rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+        similar_files = []
 
-          {
-            name: namespaced_name,
-            path: file[:path]
-          }
-        end
+        %w[app/controllers app/models app/services app/service].each do |dir|
+          next unless Dir.exist?(File.join(rails_root, dir))
 
-        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]}")
+          Dir.glob(File.join(rails_root, dir, '**', "*#{base_name}*.rb")).each do |file|
+            similar_files << file.gsub(/^#{Regexp.escape(rails_root)}\//, '')
           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
+        similar_files
       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)
+      def generate_test_for_file(file_path, method_name, type)
+        file_object = FileTypeDetector.build_file_object(file_path, type)
+        methods = extract_methods_for_type(file_object, type)
 
         if methods.empty?
-          puts @pastel.yellow("⚠️  No methods found in #{other_file[:name]}")
+          puts @pastel.yellow("⚠️  No methods found in #{file_object[:name]}")
           return
         end
 
-        method_info = methods.find { |method| method[:name].downcase == method_name.downcase }
+        method_info = methods.find { |m| m[:name].downcase == method_name.downcase }
 
         unless method_info
-          puts @pastel.red("❌ Method '#{method_name}' not found in #{other_file[:name]}")
+          puts @pastel.red("❌ Method '#{method_name}' not found in #{file_object[: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
+          methods.first(10).each { |m| puts @pastel.dim("  • #{m[:name]}") }
           return
         end
 
-        puts @pastel.bright_white("🎯 Generating test for #{other_file[:name]}##{method_info[:name]}...")
+        puts @pastel.bright_white("🎯 Generating test for #{file_object[:name]}##{method_info[:name]}...")
 
-        result = Tng::Services::TestGenerator.new(@http_client).run_for_other_method(other_file, method_info)
+        result = generate_test_result(file_object, method_info, type)
 
         if result && result[:file_path]
           @show_post_generation_menu.call(result)
@@ -299,21 +98,24 @@ module Tng
         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
+      def extract_methods_for_type(file_object, type)
+        case type
+        when "controller" then extract_controller_methods(file_object)
+        when "model" then extract_model_methods(file_object)
+        when "service" then extract_service_methods(file_object)
+        else extract_other_methods(file_object)
         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)
+      def generate_test_result(file_object, method_info, type)
+        generator = Tng::Services::TestGenerator.new(@http_client)
+
+        case type
+        when "controller" then generator.run_for_controller_method(file_object, method_info)
+        when "model" then generator.run_for_model_method(file_object, method_info)
+        when "service" then generator.run_for_service_method(file_object, method_info)
+        else generator.run_for_other_method(file_object, method_info)
         end
-        file_path # fallback if no match
       end
     end
   end

data/lib/tng/services/extract_methods.rb

@@ -4,32 +4,28 @@ module Tng
   module Services
     module ExtractMethods
       def extract_controller_methods(controller)
-        methods = Tng::Analyzers::Controller.methods_for_controller(controller[:name])
-        Array(methods)
+        Tng::Analyzers::Controller.methods_for_controller(controller[:name]) || []
       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)
+        Tng::Analyzers::Model.methods_for_model(model[:name]) || []
       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)
+        Tng::Analyzers::Service.methods_for_service(service[:name]) || []
       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)
+        Tng::Analyzers::Other.methods_for_other(other_file[:name], other_file[:path]) || []
       rescue StandardError => e
         puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing file: #{e.message}", Tng::UI::Theme.color(:error)))
         []

data/lib/tng/services/file_type_detector.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+
+module Tng
+  module Services
+    class FileTypeDetector
+      class << self
+        TYPE_PATTERNS = {
+          /app\/controllers\// => 'controller',
+          /app\/models\// => 'model',
+          /app\/services?\// => 'service',
+          /app\/jobs\// => 'job',
+          /app\/helpers\// => 'helper',
+          /(?:app\/)?libs?\// => 'lib',
+          /app\/mailers\// => 'mailer',
+          /app\/channels\// => 'channel',
+          /app\/decorators\// => 'decorator',
+          /app\/presenters\// => 'presenter',
+          /app\/serializers\// => 'serializer',
+          /app\/policies\// => 'policy',
+          /app\/forms\// => 'form',
+          /app\/queries\// => 'query',
+          /app\/graphql\/resolvers\// => 'resolver',
+          /app\/graphql\/types\// => 'type',
+          /app\/graphql\/mutations\// => 'mutation',
+          /app\/graphql\/loaders\// => 'loader',
+          /app\/graphql\/schemas\// => 'schema',
+          /app\/graphql\// => 'graphql'
+        }.freeze
+
+        PATH_MAPPINGS = {
+          'controller' => 'app/controllers',
+          'model' => 'app/models',
+          'service' => 'app/services?',
+          'job' => 'app/jobs',
+          'helper' => 'app/helpers',
+          'lib' => 'lib',
+          'mailer' => 'app/mailers',
+          'channel' => 'app/channels',
+          'decorator' => 'app/decorators',
+          'presenter' => 'app/presenters',
+          'serializer' => 'app/serializers',
+          'policy' => 'app/policies',
+          'form' => 'app/forms',
+          'query' => 'app/queries',
+          'resolver' => 'app/graphql/resolvers',
+          'type' => 'app/graphql/types',
+          'mutation' => 'app/graphql/mutations',
+          'loader' => 'app/graphql/loaders',
+          'schema' => 'app/graphql/schemas',
+          'graphql' => 'app/graphql'
+        }.freeze
+
+        def detect_type(file_path)
+          normalized_path = normalize_path(file_path)
+          TYPE_PATTERNS.find { |pattern, _| normalized_path.match?(pattern) }&.last || 'other'
+        end
+
+        def normalize_path(file_path)
+          path = file_path.sub(/\.rb$/, '')
+          path.start_with?('/') ? path : (find_file_in_project(path) || path)
+        end
+
+        SEARCH_PATHS = %w[
+          app/controllers app/models app/services app/service
+          app/jobs app/helpers app/mailers app/channels
+          app/decorators app/presenters app/serializers
+          app/policies app/forms app/queries app/graphql
+          lib app/lib
+        ].freeze
+
+        def find_file_in_project(file_name)
+          file_with_ext = file_name.end_with?('.rb') ? file_name : "#{file_name}.rb"
+
+          return File.expand_path(file_with_ext) if File.exist?(file_with_ext)
+
+          rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+
+          SEARCH_PATHS.each do |dir|
+            full_path = File.join(rails_root, dir, file_with_ext)
+            return full_path if File.exist?(full_path)
+
+            found_files = Dir.glob(File.join(rails_root, dir, '**', file_with_ext))
+            return found_files.first unless found_files.empty?
+          end
+
+          nil
+        end
+
+        def resolve_file_path(file_path)
+          resolved = if file_path.start_with?('/')
+                       File.exist?(file_path) ? file_path : File.exist?("#{file_path}.rb") ? "#{file_path}.rb" : nil
+                     else
+                       found = find_file_in_project(file_path)
+                       found ? File.expand_path(found) : nil
+                     end
+
+          resolved
+        end
+
+        def extract_relative_path(file_path, type)
+          base_path = PATH_MAPPINGS[type]
+          return File.basename(file_path, '.rb') unless base_path
+
+          pattern = base_path == 'lib' ? %r{^.*/#{base_path}/} : %r{^.*#{base_path}/}
+          file_path.gsub(pattern, '').gsub('.rb', '')
+        end
+
+        def build_file_object(file_path, type)
+          actual_file_path = File.expand_path(file_path)
+          relative_path = extract_relative_path(actual_file_path, type)
+          namespaced_name = relative_path.split('/').map(&:camelize).join('::')
+
+          {
+            name: namespaced_name,
+            path: actual_file_path,
+            type: type
+          }
+        end
+      end
+    end
+  end
+end