tng 0.2.1

data/lib/tng/utils.rb

@@ -0,0 +1,325 @@
+require "yaml"
+require "json"
+require "fileutils"
+require "prism"
+
+module Tng
+  module Utils
+    def clear_screen
+      system("clear") || system("cls")
+    end
+
+    def center_text(text, width = nil)
+      width ||= @terminal_width || 80 # Use fallback if still nil
+      lines = text.split("\n")
+      lines.map do |line|
+        # Remove ANSI color codes for length calculation
+        clean_line = line.gsub(/\e\[[0-9;]*m/, "")
+        padding = [(width - clean_line.length) / 2, 0].max
+        " " * padding + line
+      end.join("\n")
+    end
+
+    def copy_to_clipboard(text)
+      # Try to copy to clipboard
+      if system("which pbcopy > /dev/null 2>&1")
+        system("echo '#{text}' | pbcopy")
+        success_msg = @pastel.green("✅ Command copied to clipboard!")
+      elsif system("which xclip > /dev/null 2>&1")
+        system("echo '#{text}' | xclip -selection clipboard")
+        success_msg = @pastel.green("✅ Command copied to clipboard!")
+      else
+        success_msg = @pastel.yellow("📋 Copy this command:")
+        puts center_text(success_msg)
+        puts center_text(@pastel.bright_white(text))
+        @prompt.keypress(center_text(@pastel.dim("Press any key to continue...")))
+        return
+      end
+
+      puts center_text(success_msg)
+      @prompt.keypress(center_text(@pastel.dim("Press any key to continue...")))
+    end
+
+    def load_rails_environment
+      # Use bundler environment to avoid gem conflicts
+      require "bundler/setup"
+      require "./config/environment"
+      true
+    rescue LoadError => e
+      puts "Failed to load Rails: #{e.message}"
+      false
+    end
+
+    def find_rails_root
+      current_dir = Dir.pwd
+      while current_dir != "/"
+        return current_dir if File.exist?(File.join(current_dir, "config", "application.rb"))
+
+        current_dir = File.dirname(current_dir)
+      end
+      nil
+    end
+
+    def camelize(str, first_letter = :upper)
+      # Use Rails' camelize method if available, otherwise use custom implementation
+      if defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:camelize)
+        case first_letter
+        when :upper
+          ActiveSupport::Inflector.camelize(str, true)
+        when :lower
+          ActiveSupport::Inflector.camelize(str, false)
+        else
+          raise ArgumentError, "Invalid option, use either :upper or :lower."
+        end
+      elsif str.respond_to?(:camelize)
+        str.camelize(first_letter)
+      else
+        # Custom implementation
+        result = str.gsub(/(?:^|_)([a-z])/) { Regexp.last_match(1).upcase }
+        case first_letter
+        when :upper
+          result
+        when :lower
+          result[0].downcase + result[1..] if result.length.positive?
+        else
+          raise ArgumentError, "Invalid option, use either :upper or :lower."
+        end
+      end
+    end
+
+    def self.has_gem?(gem_name)
+      return false unless defined?(Bundler)
+
+      gemfile_specs = Bundler.load.specs
+      gemfile_specs.any? { |spec| spec.name == gem_name }
+    rescue StandardError
+      false
+    end
+
+    def self.save_test_file(test_content)
+      puts "📋 Raw API response: #{test_content[0..200]}..." if ENV["DEBUG"]
+      parsed_response = JSON.parse(test_content)
+
+      if parsed_response["error"]
+        puts "❌ API responded with an error: #{parsed_response["error"]}"
+        return
+      end
+      # Validate required fields
+      unless parsed_response["file_content"]
+        puts "❌ API response missing file_content field"
+        puts "📋 Response keys: #{parsed_response.keys.inspect}"
+        return
+      end
+
+      # Handle both possible field names for file path
+      file_path = parsed_response["test_file_path"] || parsed_response["file_path"] || parsed_response["file_name"] || parsed_response["file"]
+      unless file_path
+        puts "❌ API response missing test_file_path or file_path field"
+        puts "📋 Response keys: #{parsed_response.keys.inspect}"
+        return
+      end
+
+      begin
+        File.write(file_path, parsed_response["file_content"])
+      rescue Errno::ENOENT
+        # Create directory if it doesn't exist
+        FileUtils.mkdir_p(File.dirname(file_path))
+        File.write(file_path, parsed_response["file_content"])
+      end
+      puts "✅ Test generated successfully!"
+      absolute_path = File.expand_path(file_path)
+      puts "Please review the generated tests at \e]8;;file://#{absolute_path}\e\\#{file_path}\e]8;;\e\\"
+
+      # Count tests in the generated file
+      test_count = count_tests_in_file(file_path)
+
+      # Determine run command based on test framework
+      run_command = if file_path.include?("/spec/")
+                      "bundle exec rspec #{file_path}"
+                    else
+                      "bundle exec rails test #{file_path}"
+                    end
+
+      # Return file information for CLI to use
+      {
+        file_path: file_path,
+        absolute_path: absolute_path,
+        run_command: run_command,
+        test_class_name: parsed_response["test_class_name"],
+        test_count: test_count
+      }
+    end
+
+    def self.fixture_content
+      factory_library = Tng.factory_library || "active_record"
+
+      case factory_library.downcase
+      when "fixtures"
+        load_all_fixtures_data
+      when "fabrication", "fabricator"
+        load_all_fabricator_data
+      when "factory_girl", "factory_bot"
+        load_all_factory_data
+      when "active_record"
+        load_all_active_record_data
+      else
+        puts "⚠️  Warning: Unknown factory library '#{factory_library}'. Using Active Record object creation as fallback."
+        load_all_fixtures_data
+      end
+    end
+
+    def self.load_all_fixtures_data
+      fixture_data = {}
+      # TODO: Load proper folder for Rspec. This is only valid for minitest.
+      fixtures_dir = Rails.root.join("test", "fixtures")
+
+      return fixture_data unless Dir.exist?(fixtures_dir)
+
+      fixture_files = Dir.glob("#{fixtures_dir}/*.yml")
+
+      fixture_files.each do |fixture_file|
+        model_name = File.basename(fixture_file, ".yml")
+
+        begin
+          fixtures = YAML.load_file(fixture_file)
+          fixture_data[model_name] = fixtures
+        rescue StandardError => e
+          puts "⚠️  Warning: Could not load fixture file #{fixture_file}: #{e.message}"
+        end
+      end
+
+      fixture_data
+    end
+
+    def self.load_all_fabricator_data
+      fabricator_data = {}
+      fabricators_dir = Rails.root.join("spec", "fabricators")
+
+      return fabricator_data unless Dir.exist?(fabricators_dir)
+
+      Dir.glob("#{fabricators_dir}/*_fabricator.rb").each do |fabricator_file|
+        model_name = File.basename(fabricator_file, "_fabricator.rb")
+
+        begin
+          content = File.read(fabricator_file)
+          fabricator_data[model_name] = parse_fabricator_structure(content, model_name)
+        rescue StandardError => e
+          puts "⚠️  Warning: Could not load fabricator file #{fabricator_file}: #{e.message}"
+        end
+      end
+
+      fabricator_data
+    end
+
+    def self.load_all_factory_data
+      factory_data = {}
+      factory_dirs = [
+        Rails.root.join("spec", "factories"),
+        Rails.root.join("test", "factories")
+      ]
+
+      factory_dirs.each do |factory_dir|
+        next unless Dir.exist?(factory_dir)
+
+        Dir.glob("#{factory_dir}/*.rb").each do |factory_file|
+          content = File.read(factory_file)
+
+          begin
+            # Extract all factory definitions from the file
+            content.scan(/factory\s+:(\w+)\s+do/) do |match|
+              model_name = match[0]
+              factory_data[model_name] = parse_factory_structure(content, model_name)
+            end
+          rescue StandardError => e
+            puts "⚠️  Warning: Could not load factory file #{factory_file}: #{e.message}"
+          end
+        end
+      end
+
+      factory_data
+    end
+
+    def self.parse_fabricator_structure(content, model_name)
+      # Parse fabricator file to extract attribute structure
+      attributes = {}
+
+      # Look for Fabricator definitions
+      content.scan(/Fabricator\(:#{model_name}\) do \|f\|(.*?)end/m) do |block|
+        block[0].scan(/f\.(\w+)\s+(.+)/) do |attr, value|
+          attributes[attr] = parse_attribute_value(value)
+        end
+      end
+
+      { "attributes" => attributes, "type" => "fabricator" }
+    end
+
+    def self.parse_factory_structure(content, model_name)
+      # Parse factory file to extract attribute structure
+      attributes = {}
+
+      # Look for factory definitions
+      content.scan(/factory :#{model_name} do(.*?)end/m) do |block|
+        block[0].scan(/(\w+)\s+(.+)/) do |attr, value|
+          attributes[attr] = parse_attribute_value(value)
+        end
+      end
+
+      { "attributes" => attributes, "type" => "factory" }
+    end
+
+    def self.parse_attribute_value(value)
+      # Clean up and parse attribute values
+      value.strip.gsub(/^["']|["']$/, "")
+    end
+
+    def self.load_all_active_record_data
+      []
+    end
+
+    def self.count_tests_in_file(file_path)
+      return 0 unless File.exist?(file_path)
+
+      begin
+        content = File.read(file_path)
+        result = Prism.parse(content)
+        return 0 unless result.success?
+
+        count_test_nodes(result.value)
+      rescue StandardError => e
+        puts "⚠️  Warning: Could not parse #{file_path}: #{e.message}" if ENV["DEBUG"]
+        0
+      end
+    end
+
+    private_class_method def self.count_test_nodes(node)
+      return 0 unless node.respond_to?(:child_nodes)
+
+      count = 0
+
+      # Check if current node is a test
+      count += 1 if test_node?(node)
+
+      # Recursively check child nodes
+      node.child_nodes.each do |child|
+        count += count_test_nodes(child) if child
+      end
+
+      count
+    end
+
+    private_class_method def self.test_node?(node)
+      case node
+      when Prism::DefNode
+        # Minitest: def test_something
+        node.name.to_s.start_with?("test_")
+      when Prism::CallNode
+        # RSpec: it "...", specify "..."
+        # Minitest: test "..."
+        method_name = node.name.to_s
+        %w[it specify test].include?(method_name)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/tng/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tng
+  VERSION = "0.2.1"
+end

data/lib/tng.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+$VERBOSE = nil
+
+require_relative "tng/version"
+require_relative "tng/utils"
+require_relative "tng/api/http_client"
+require_relative "tng/ui/theme"
+require_relative "tng/ui/post_install_box"
+require_relative "tng/ui/authentication_warning_display"
+require_relative "tng/services/test_generator"
+
+require_relative "tng/railtie" if defined?(Rails)
+
+begin
+  platform = RUBY_PLATFORM
+  binary_name = if platform.include?("darwin") # macOS
+                  "tng.bundle"
+                elsif platform.include?("linux")
+                  "tng.so"
+                else
+                  raise "Unsupported platform: #{platform}"
+                end
+
+  binary_paths = [
+    File.expand_path("../binaries/#{binary_name}", __dir__), # From gem root
+    File.expand_path("../../binaries/#{binary_name}", __FILE__), # Alternative path
+    File.expand_path("binaries/#{binary_name}", __dir__) # Direct from lib
+  ]
+
+  loaded = false
+  binary_paths.each do |path|
+    next unless File.exist?(path)
+
+    require path
+    loaded = true
+    break
+  end
+
+  raise LoadError, "Could not find binary at any of: #{binary_paths.join(", ")}" unless loaded
+rescue LoadError => e
+  puts "Warning: Could not load native extension: #{e.message}"
+  puts "Some functionality may not be available."
+end
+
+# Load Ruby analyzers after native binary to ensure Rust classes are available
+# Ruby analyzers depend on Rust classes (e.g., Tng::Analyzer::Controller)
+require_relative "tng/analyzers/controller"
+require_relative "tng/analyzers/model"
+require_relative "tng/analyzers/service"
+
+module Tng
+  class Error < StandardError; end
+
+  @config = {
+    api_key: nil,
+    base_url: "https://app.tng.sh/",
+    read_source_code: true,
+    read_test_code: true,
+    testing_framework: "minitest",
+    authentication_enabled: false,
+    authorization_library: nil,
+    authentication_library: nil,
+    authentication_methods: [],
+    mock_library: "minitest/mock",
+    http_mock_library: "webmock",
+    factory_library: "active_record"
+  }
+
+  def self.configure
+    yield(self) if block_given?
+  end
+
+  def self.config
+    @config
+  end
+
+  def self.api_key=(value)
+    @config[:api_key] = value
+  end
+
+  def self.api_key
+    @config[:api_key]
+  end
+
+  def self.base_url=(value)
+    @config[:base_url] = value
+  end
+
+  def self.base_url
+    @config[:base_url]
+  end
+
+  def self.read_source_code=(value)
+    @config[:read_source_code] = value
+  end
+
+  def self.read_source_code
+    @config[:read_source_code]
+  end
+
+  def self.read_test_code=(value)
+    @config[:read_test_code] = value
+  end
+
+  def self.read_test_code
+    @config[:read_test_code]
+  end
+
+  def self.testing_framework=(value)
+    @config[:testing_framework] = value
+    initialize_framework_defaults(value)
+  end
+
+  def self.testing_framework
+    @config[:testing_framework]
+  end
+
+  def self.authentication_enabled=(value)
+    @config[:authentication_enabled] = value
+  end
+
+  def self.authentication_enabled
+    @config[:authentication_enabled]
+  end
+
+  def self.authentication_library=(value)
+    @config[:authentication_library] = value
+  end
+
+  def self.authentication_library
+    @config[:authentication_library]
+  end
+
+  def self.authorization_library=(value)
+    @config[:authorization_library] = value
+  end
+
+  def self.authorization_library
+    @config[:authorization_library]
+  end
+
+  def self.authentication_methods=(value)
+    @config[:authentication_methods] = value
+  end
+
+  def self.authentication_methods
+    @config[:authentication_methods]
+  end
+
+  def self.mock_library=(value)
+    @config[:mock_library] = value
+  end
+
+  def self.mock_library
+    @config[:mock_library]
+  end
+
+  def self.http_mock_library=(value)
+    @config[:http_mock_library] = value
+  end
+
+  def self.http_mock_library
+    @config[:http_mock_library]
+  end
+
+  def self.factory_library=(value)
+    @config[:factory_library] = value
+  end
+
+  def self.factory_library
+    @config[:factory_library]
+  end
+
+  def self.test_style=(value)
+    @config[:test_style] = value
+  end
+
+  def self.test_style
+    @config[:test_style]
+  end
+
+  def self.setup_style=(value)
+    @config[:setup_style] = value
+  end
+
+  def self.setup_style
+    @config[:setup_style]
+  end
+
+  def self.assertion_style=(value)
+    @config[:assertion_style] = value
+  end
+
+  def self.assertion_style
+    @config[:assertion_style]
+  end
+
+  def self.teardown_style=(value)
+    @config[:teardown_style] = value
+  end
+
+  def self.teardown_style
+    @config[:teardown_style]
+  end
+
+  def self.describe_style=(value)
+    @config[:describe_style] = value
+  end
+
+  def self.describe_style
+    @config[:describe_style]
+  end
+
+  def self.context_style=(value)
+    @config[:context_style] = value
+  end
+
+  def self.context_style
+    @config[:context_style]
+  end
+
+  def self.it_style=(value)
+    @config[:it_style] = value
+  end
+
+  def self.it_style
+    @config[:it_style]
+  end
+
+  def self.before_style=(value)
+    @config[:before_style] = value
+  end
+
+  def self.before_style
+    @config[:before_style]
+  end
+
+  def self.after_style=(value)
+    @config[:after_style] = value
+  end
+
+  def self.after_style
+    @config[:after_style]
+  end
+
+  def self.let_style=(value)
+    @config[:let_style] = value
+  end
+
+  def self.let_style
+    @config[:let_style]
+  end
+
+  def self.subject_style=(value)
+    @config[:subject_style] = value
+  end
+
+  def self.subject_style
+    @config[:subject_style]
+  end
+
+  def self.authentication_configured?
+    return false unless authentication_enabled
+    return false if authentication_methods.nil? || authentication_methods.empty?
+
+    authentication_methods.all? do |method|
+      method.is_a?(Hash) &&
+        method.key?(:method) && !method[:method].to_s.strip.empty? &&
+        method.key?(:file_location) && !method[:file_location].to_s.strip.empty? &&
+        method.key?(:auth_type) && !method[:auth_type].to_s.strip.empty?
+    end
+  end
+
+  def self.initialize_framework_defaults(framework)
+    if framework == "minitest"
+      @config.merge!({
+                       test_style: "spec",
+                       setup_style: false,
+                       assertion_style: "assert",
+                       teardown_style: false
+                     })
+      @config.delete(:describe_style)
+      @config.delete(:context_style)
+      @config.delete(:it_style)
+      @config.delete(:before_style)
+      @config.delete(:after_style)
+      @config.delete(:let_style)
+      @config.delete(:subject_style)
+    elsif framework == "rspec"
+      @config.merge!({
+                       describe_style: true,
+                       context_style: "context",
+                       it_style: "it",
+                       before_style: "before",
+                       after_style: "after",
+                       let_style: true,
+                       subject_style: true
+                     })
+      @config.delete(:test_style)
+      @config.delete(:setup_style)
+      @config.delete(:assertion_style)
+      @config.delete(:teardown_style)
+    end
+  end
+
+  initialize_framework_defaults(@config[:testing_framework])
+end

data/tng.gemspec

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "lib/tng/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "tng"
+  spec.version = Tng::VERSION
+  spec.authors = ["ralucab"]
+  spec.email = ["claudiu.garba@gmail.com"]
+
+  spec.summary = "TNG generates tests using static code analysis and LLM"
+  spec.description = "TNG (Test Next Generation) is a Rails gem that automatically generates comprehensive test files by analyzing your Ruby code using static analysis and AI. It supports models, controllers, and services with intelligent test case generation."
+  spec.homepage = "https://tng.sh/"
+  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_rubygems_version = ">= 3.3.11"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/tng-sh/tng-rails"
+  spec.license = "Nonstandard"
+  spec.metadata["license_uri"] = "https://github.com/tng-sh/tng-rails/blob/master/LICENSE.md"
+
+  # Package pre-compiled binaries and exclude the Rust source code.
+  spec.files = Dir.glob("lib/**/*.rb") +
+               Dir.glob("binaries/*") +
+               Dir.glob("bin/**/*") +
+               ["LICENSE.md", "README.md", "Gemfile", "Rakefile", "tng.gemspec"]
+
+  spec.bindir = "bin"
+  spec.executables = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = []
+
+  spec.add_dependency "httpx", "~> 1.5"
+  spec.add_dependency "pastel", "~> 0.8.0"
+  spec.add_dependency "prism", "~> 1.4.0"
+  spec.add_dependency "rb_sys", "~> 0.9.91"
+  spec.add_dependency "tty-box", "~> 0.7"
+  spec.add_dependency "tty-file", "~> 0.10"
+  spec.add_dependency "tty-option", "~> 0.3"
+  spec.add_dependency "tty-progressbar", "~> 0.18.3"
+  spec.add_dependency "tty-prompt", "~> 0.23"
+  spec.add_dependency "tty-reader", "~> 0.9"
+  spec.add_dependency "tty-screen", "~> 0.8"
+  spec.add_dependency "tty-spinner", "~> 0.9.3"
+  spec.add_dependency "tty-table", "~> 0.12"
+
+  spec.post_install_message = begin
+    require_relative "lib/tng/ui/post_install_box"
+    PostInstallBox.new(spec.version).render
+  rescue LoadError, StandardError
+    "TNG v#{spec.version} installed successfully!\n" +
+      "Run 'rails g tng:install' to get started.\n" +
+      "Use 'bundle exec tng --help' for usage information."
+  end
+end