tng 0.2.1

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Tng
+  module Analyzers
+    class Service
+      def self.files_in_dir(dir = nil)
+        base_dirs = if dir.nil?
+                      ["app/services", "app/service"].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_service_files(full_path)
+        end
+      end
+
+      def self.value_for_service(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        Tng::Analyzer::Service.parse_service_file(file_path)
+      end
+
+      def self.read_test_file_for_service(service_path)
+        files = find_test_file_for_service(service_path)
+
+        files.map do |file_path|
+          {
+            path: file_path,
+            content: File.read(file_path)
+          }
+        end
+      end
+
+      def self.find_test_file_for_service(service_path)
+        service_name = File.basename(service_path, ".rb")
+        testing_framework = Tng.testing_framework
+        return [] if testing_framework.nil?
+
+        paths = if testing_framework.downcase == "rspec"
+                  [
+                    "spec/services/#{service_name}_spec.rb",
+                    "spec/service/#{service_name}_spec.rb"
+                  ]
+                else
+                  [
+                    "test/services/#{service_name}_test.rb",
+                    "test/service/#{service_name}_test.rb"
+                  ]
+                end
+
+        paths.select { |path| File.exist?(path) }
+      end
+
+      def self.methods_for_service(service_name)
+        raise "service_name is required" if service_name.nil?
+
+        begin
+          # Load the service class
+          service_class = service_name.constantize
+
+          instance_methods = service_class.public_instance_methods(false)
+          class_methods = service_class.public_methods(false) - Class.public_methods
+
+          # Try to get source file from any method, fallback to const_source_location
+          service_file = nil
+
+          # First try to get file from an instance method
+          if instance_methods.any?
+            begin
+              service_file = service_class.instance_method(instance_methods.first).source_location&.first
+            rescue StandardError
+              # Method might not have source location, continue
+            end
+          end
+
+          # Fallback to const_source_location if no method source found
+          service_file ||= service_class.const_source_location(service_class.name.split("::").last)&.first
+
+          service_methods = if service_file && File.exist?(service_file)
+                              source_code = File.read(service_file)
+                              result = Prism.parse(source_code)
+
+                              defined_methods = []
+                              extract_method_names(result.value, defined_methods)
+
+                              filtered_instance_methods = instance_methods.select do |method_name|
+                                method = service_class.instance_method(method_name)
+                                next false unless method.owner == service_class
+
+                                defined_methods.include?(method_name.to_s)
+                              end
+
+                              filtered_class_methods = class_methods.select do |method_name|
+                                defined_methods.include?(method_name.to_s)
+                              end
+
+                              filtered_instance_methods + filtered_class_methods
+                            else
+                              []
+                            end
+
+          service_methods.map { |method_name| { name: method_name.to_s } }
+        rescue NameError => e
+          puts "❌ Could not load service class #{service_name}: #{e.message}"
+          []
+        rescue StandardError => e
+          puts "❌ Error analyzing service #{service_name}: #{e.message}"
+          []
+        end
+      end
+
+      def self.extract_method_names(node, methods)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        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|
+            extract_method_names(child, methods)
+          end
+        end
+
+        node.child_nodes.each do |child|
+          extract_method_names(child, methods)
+        end
+      end
+
+      def self.find_service_files(dir)
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**", "*.rb")).map do |file_path|
+          relative_path = file_path.gsub("#{Dir.pwd}/", "")
+          {
+            file: File.basename(file_path),
+            path: file_path,
+            relative_path: relative_path
+          }
+        end
+      end
+    end
+  end
+end

data/lib/tng/api/http_client.rb

@@ -0,0 +1,100 @@
+require "httpx"
+
+module Tng
+  class HttpClient
+    def initialize(api_endpoint, api_key)
+      @api_endpoint = api_endpoint
+      @api_key = api_key
+      @timeout = {
+        connect_timeout: 300,
+        read_timeout: 300,
+        write_timeout: 300,
+        request_timeout: 300
+      }
+    end
+
+    def post(path, payload: {}, headers: {})
+      merged_headers = json_default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).post(
+        "#{@api_endpoint}/#{path}",
+        json: payload,
+        headers: merged_headers
+      )
+
+      debug_response("POST #{path}", response) if debug_enabled?
+      response
+    end
+
+    def post_binary(path, data, headers: {})
+      merged_headers = stream_default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).post(
+        "#{@api_endpoint}/#{path}",
+        body: data,
+        headers: merged_headers
+      )
+
+      debug_response("POST #{path} (binary)", response) if debug_enabled?
+      response
+    end
+
+    def get(path, headers: {})
+      merged_headers = json_default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).get(
+        "#{@api_endpoint}/#{path}",
+        headers: merged_headers
+      )
+
+      debug_response("GET #{path}", response) if debug_enabled?
+      response
+    end
+
+    def ping
+      response = HTTPX.with(timeout: @timeout).get("#{@api_endpoint}/ping")
+      debug_response("GET /ping", response) if debug_enabled?
+      response
+    end
+
+    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}"
+
+      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})"
+        else
+          puts "   Body: #{body}"
+        end
+      end
+      puts "   " + "─" * 50
+    end
+  end
+end

data/lib/tng/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Tng
+  class Railtie < Rails::Railtie
+    generators do
+      require_relative "../generators/tng/install_generator"
+    end
+  end
+end