tng 0.1.6 → 0.2.1

data/lib/tng/analyzers/model.rb

@@ -106,6 +106,15 @@ module Tng
         when Prism::DefNode
           # Both instance and class methods (def self.method_name)
           methods << node.name.to_s
+        when Prism::CallNode
+          # Handle scope definitions: scope :name, -> { ... }
+          if node.name == :scope && node.arguments&.arguments&.any?
+            first_arg = node.arguments.arguments.first
+            if first_arg.is_a?(Prism::SymbolNode)
+              scope_name = first_arg.value
+              methods << scope_name if scope_name
+            end
+          end
         when Prism::SingletonClassNode
           # Methods inside class << self blocks
           node.body&.child_nodes&.each do |child|

data/lib/tng/analyzers/other.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Tng
+  module Analyzers
+    class Other
+      # Directories to scan for "other" files
+      OTHER_DIRECTORIES = %w[
+        app/jobs
+        app/helpers
+        lib
+        libs
+        app/lib
+        app/libs
+        app/mailers
+        app/channels
+        app/decorators
+        app/presenters
+        app/serializers
+        app/policies
+        app/forms
+        app/queries
+        app/graphql
+        app/graphql/resolvers
+        app/graphql/types
+        app/graphql/mutations
+        app/graphql/loaders
+        app/graphql/schemas
+      ].freeze
+
+      def self.files_in_dir(dir = nil)
+        base_dirs = if dir.nil?
+                      OTHER_DIRECTORIES.select { |d| Dir.exist?(File.join(Dir.pwd, d)) }
+                    else
+                      [dir]
+                    end
+
+        return [] if base_dirs.empty?
+
+        base_dirs.flat_map do |base_dir|
+          full_path = File.join(Dir.pwd, base_dir)
+          find_other_files(full_path, base_dir)
+        end
+      end
+
+      def self.value_for_other(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        # For now, use the same parsing logic as services
+        # We can enhance this later if needed for specific file types
+        Tng::Analyzer::Service.parse_service_file(file_path)
+      end
+
+      def self.read_test_file_for_other(other_path)
+        files = find_test_file_for_other(other_path)
+
+        files.map do |file_path|
+          {
+            path: file_path,
+            content: File.read(file_path)
+          }
+        end
+      end
+
+      def self.find_test_file_for_other(other_path)
+        # Extract the file type and name for test file discovery
+        file_type = determine_file_type(other_path)
+        file_name = File.basename(other_path, ".rb")
+        testing_framework = Tng.testing_framework
+        return [] if testing_framework.nil?
+
+        paths = if testing_framework.downcase == "rspec"
+                  build_rspec_test_paths(file_type, file_name)
+                else
+                  build_minitest_test_paths(file_type, file_name)
+                end
+
+        paths.select { |path| File.exist?(path) }
+      end
+
+      def self.methods_for_other(other_name, file_path)
+        raise "other_name is required" if other_name.nil?
+        raise "file_path is required" if file_path.nil?
+
+        begin
+          # Try to load the class/module if possible
+          if File.exist?(file_path)
+            source_code = File.read(file_path)
+            result = Prism.parse(source_code)
+
+            public_methods = []
+            extract_public_method_names(result.value, public_methods, :public)
+
+            # Return the public methods found in the source file
+            public_methods.map { |method_name| { name: method_name.to_s } }
+          else
+            []
+          end
+        rescue StandardError => e
+          puts "❌ Error analyzing file #{other_name}: #{e.message}"
+          []
+        end
+      end
+
+      def self.extract_public_method_names(node, methods, current_visibility = :public)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::DefNode
+          # Only add methods that are public
+          methods << node.name.to_s if current_visibility == :public
+        when Prism::CallNode
+          # Handle visibility modifiers (private, protected, public)
+          if node.receiver.nil? && node.arguments.nil?
+            case node.name
+            when :private
+              current_visibility = :private
+            when :protected
+              current_visibility = :protected
+            when :public
+              current_visibility = :public
+            end
+
+          end
+        when Prism::SingletonClassNode
+          # Methods inside class << self blocks - always public by default
+          node.body&.child_nodes&.each do |child|
+            extract_public_method_names(child, methods, :public)
+          end
+        end
+
+        # Recursively process child nodes with current visibility
+        node.child_nodes.each do |child|
+          extract_public_method_names(child, methods, current_visibility)
+        end
+      end
+
+      def self.find_other_files(dir, _base_dir)
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**", "*.rb")).map do |file_path|
+          relative_path = file_path.gsub("#{Dir.pwd}/", "")
+          file_type = determine_file_type(file_path)
+
+          {
+            file: File.basename(file_path),
+            path: file_path,
+            relative_path: relative_path,
+            type: file_type
+          }
+        end
+      end
+
+      def self.determine_file_type(file_path)
+        case file_path
+        when %r{app/jobs}
+          "job"
+        when %r{app/helpers}
+          "helper"
+        when %r{(?:app/)?libs?(?:/|$)}
+          "lib"
+        when %r{app/mailers}
+          "mailer"
+        when %r{app/channels}
+          "channel"
+        when %r{app/decorators}
+          "decorator"
+        when %r{app/presenters}
+          "presenter"
+        when %r{app/serializers}
+          "serializer"
+        when %r{app/policies}
+          "policy"
+        when %r{app/forms}
+          "form"
+        when %r{app/queries}
+          "query"
+        when %r{app/graphql/resolvers}
+          "resolver"
+        when %r{app/graphql/types}
+          "type"
+        when %r{app/graphql/mutations}
+          "mutation"
+        when %r{app/graphql/loaders}
+          "loader"
+        when %r{app/graphql/schemas}
+          "schema"
+        when %r{app/graphql}
+          "graphql"
+        else
+          "other"
+        end
+      end
+
+      def self.build_rspec_test_paths(file_type, file_name)
+        case file_type
+        when "job"
+          ["spec/jobs/#{file_name}_spec.rb"]
+        when "helper"
+          ["spec/helpers/#{file_name}_spec.rb"]
+        when "lib"
+          ["spec/lib/#{file_name}_spec.rb"]
+        when "mailer"
+          ["spec/mailers/#{file_name}_spec.rb"]
+        when "channel"
+          ["spec/channels/#{file_name}_spec.rb"]
+        when "query"
+          ["spec/queries/#{file_name}_spec.rb"]
+        when "decorator"
+          ["spec/decorators/#{file_name}_spec.rb"]
+        when "presenter"
+          ["spec/presenters/#{file_name}_spec.rb"]
+        when "serializer"
+          ["spec/serializers/#{file_name}_spec.rb"]
+        when "policy"
+          ["spec/policies/#{file_name}_spec.rb"]
+        when "form"
+          ["spec/forms/#{file_name}_spec.rb"]
+        when "resolver"
+          ["spec/graphql/resolvers/#{file_name}_spec.rb"]
+        when "type"
+          ["spec/graphql/types/#{file_name}_spec.rb"]
+        when "mutation"
+          ["spec/graphql/mutations/#{file_name}_spec.rb"]
+        when "loader"
+          ["spec/graphql/loaders/#{file_name}_spec.rb"]
+        when "schema"
+          ["spec/graphql/schemas/#{file_name}_spec.rb"]
+        when "graphql"
+          ["spec/graphql/#{file_name}_spec.rb"]
+        else
+          ["spec/#{file_type}s/#{file_name}_spec.rb"]
+        end
+      end
+
+      def self.build_minitest_test_paths(file_type, file_name)
+        case file_type
+        when "job"
+          ["test/jobs/#{file_name}_test.rb"]
+        when "helper"
+          ["test/helpers/#{file_name}_test.rb"]
+        when "lib"
+          ["test/lib/#{file_name}_test.rb"]
+        when "mailer"
+          ["test/mailers/#{file_name}_test.rb"]
+        when "channel"
+          ["test/channels/#{file_name}_test.rb"]
+        when "query"
+          ["test/queries/#{file_name}_test.rb"]
+        when "decorator"
+          ["test/decorators/#{file_name}_test.rb"]
+        when "presenter"
+          ["test/presenters/#{file_name}_test.rb"]
+        when "serializer"
+          ["test/serializers/#{file_name}_test.rb"]
+        when "policy"
+          ["test/policies/#{file_name}_test.rb"]
+        when "form"
+          ["test/forms/#{file_name}_test.rb"]
+        when "resolver"
+          ["test/graphql/resolvers/#{file_name}_test.rb"]
+        when "type"
+          ["test/graphql/types/#{file_name}_test.rb"]
+        when "mutation"
+          ["test/graphql/mutations/#{file_name}_test.rb"]
+        when "loader"
+          ["test/graphql/loaders/#{file_name}_test.rb"]
+        when "schema"
+          ["test/graphql/schemas/#{file_name}_test.rb"]
+        when "graphql"
+          ["test/graphql/#{file_name}_test.rb"]
+        else
+          ["test/#{file_type}s/#{file_name}_test.rb"]
+        end
+      end
+    end
+  end
+end

data/lib/tng/analyzers/service.rb

@@ -120,6 +120,7 @@ module Tng
         when Prism::DefNode
           # Both instance and class methods (def self.method_name)
           methods << node.name.to_s
+
         when Prism::SingletonClassNode
           # Methods inside class << self blocks
           node.body&.child_nodes&.each do |child|

data/lib/tng/api/http_client.rb

@@ -14,13 +14,7 @@ module Tng
     end
 
     def post(path, payload: {}, headers: {})
-      default_headers = {
-        "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{@api_key}",
-        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
-      }
-
-      merged_headers = default_headers.merge(headers)
+      merged_headers = json_default_headers.merge(headers)
 
       response = HTTPX.with(timeout: @timeout).post(
         "#{@api_endpoint}/#{path}",
@@ -33,13 +27,7 @@ module Tng
     end
 
     def post_binary(path, data, headers: {})
-      default_headers = {
-        "Content-Type" => "application/octet-stream",
-        "Authorization" => "Bearer #{@api_key}",
-        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
-      }
-
-      merged_headers = default_headers.merge(headers)
+      merged_headers = stream_default_headers.merge(headers)
 
       response = HTTPX.with(timeout: @timeout).post(
         "#{@api_endpoint}/#{path}",
@@ -52,13 +40,7 @@ module Tng
     end
 
     def get(path, headers: {})
-      default_headers = {
-        "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{@api_key}",
-        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
-      }
-
-      merged_headers = default_headers.merge(headers)
+      merged_headers = json_default_headers.merge(headers)
 
       response = HTTPX.with(timeout: @timeout).get(
         "#{@api_endpoint}/#{path}",
@@ -77,18 +59,34 @@ module Tng
 
     private
 
+    def stream_default_headers
+      {
+        "Content-Type" => "application/octet-stream",
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+    end
+
+    def json_default_headers
+      {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+    end
+
     def debug_enabled?
       ENV["DEBUG"] == "1"
     end
 
     def debug_response(request_info, response)
       puts "\n -> DEBUG: #{request_info}"
-      puts "   Status: #{response.status}"
-      puts "   Headers: #{response.headers.to_h}"
 
       if response.is_a?(HTTPX::ErrorResponse)
         puts "   Error: #{response.error&.message}"
       else
+        puts "   Status: #{response.status}"
+        puts "   Headers: #{response.headers.to_h}"
         body = response.body.to_s
         if body.length > 500
           puts "   Body: #{body[0..500]}... (truncated, total length: #{body.length})"