tng 0.1.0

data/lib/generators/tng/install_generator.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "yaml"
+require "tng"
+
+module Tng
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Creates a tng.sh Ruby configuration file with comprehensive authentication and authorization support"
+
+      def self.source_root
+        @source_root ||= File.expand_path("templates", __dir__)
+      end
+
+      def create_tng_configuration
+        @test_framework = detect_test_framework
+        @authentication_library = detect_authentication_library
+        @authz_library = detect_authorization_library
+        @factory_library = detect_factory_library
+
+        initializer_path = "config/initializers/tng.rb"
+
+        if File.exist?(initializer_path)
+          say "Configuration file already exists at #{initializer_path}", :yellow
+          if yes?("Do you want to overwrite it? (y/n)")
+            remove_file initializer_path
+            create_file initializer_path, ruby_configuration_template
+            say "TNG configuration file updated!", :green
+          else
+            say "Skipping configuration file creation.", :blue
+            nil
+          end
+        else
+          create_file initializer_path, ruby_configuration_template
+          say "tng.sh configuration file created at #{initializer_path}", :green
+        end
+      end
+
+      def ruby_configuration_template
+        framework_config = generate_framework_config(@test_framework)
+
+        if @authentication_library && @authentication_library != "none"
+          auth_enabled = "config.authentication_enabled = true"
+          auth_comment = " (detected: #{@authentication_library})"
+          auth_lib = "config.authentication_library = \"#{@authentication_library}\""
+        else
+          auth_enabled = "config.authentication_enabled = true"
+          auth_comment = ""
+          auth_lib = "config.authentication_library = nil"
+        end
+
+        if @authz_library && @authz_library != "none"
+          authz_lib = "config.authorization_library = \"#{@authz_library}\""
+          authz_comment = " (detected: #{@authz_library})"
+        else
+          authz_lib = "config.authorization_library = nil"
+          authz_comment = ""
+        end
+
+        factory_lib = "config.factory_library = \"#{@factory_library}\""
+
+        framework_specific = generate_framework_specific_config(@test_framework, framework_config)
+        [
+          "# frozen_string_literal: true",
+          "",
+          "return if Rails.env.production?",
+          "",
+          "Tng.configure do |config|",
+          "  config.api_key = nil",
+          "  config.base_url = \"https://app.tng.sh/\"",
+          "  config.read_source_code = true      # Options: true, false",
+          "  config.read_test_code = true        # Options: true, false",
+          "",
+          "  # Testing Framework",
+          "  config.testing_framework = \"#{@test_framework}\"      # Options: minitest, rspec",
+          framework_specific,
+          "  config.mock_library = \"#{framework_config["mock_library"]}\"      # Options: mocha, minitest/mock, rspec-mocks, nil",
+          "  config.http_mock_library = \"#{framework_config["http_mock_library"]}\"       # Options: webmock, vcr, httparty, nil",
+          "  #{factory_lib}        # Options: factory_bot, factory_girl, fabrication, fabricator, fixtures, active_record",
+          "",
+          "  # Authentication#{auth_comment}",
+          "  #{auth_enabled}      # Options: true, false",
+          "  #{auth_lib}       # Options: devise, clearance, sorcery, nil",
+          "",
+          "  # Authentication Methods (multiple methods supported)",
+          "  # Supported authentication types: session, devise, jwt, token_auth, basic_auth, oauth, headers, custom, nil",
+          "  # Uncomment and configure your authentication entry points:",
+          "  # config.authentication_methods = [",
+          "  #   {",
+          "  #     method: \"authenticate_user_via_session!\",",
+          "  #     file_location: \"app/controllers/application_controller.rb\",",
+          "  #     auth_type: \"session\"",
+          "  #   },",
+          "  #   {",
+          "  #     method: \"authenticate_user_via_api_key!\",",
+          "  #     file_location: \"app/controllers/application_controller.rb\",",
+          "  #     auth_type: \"headers\"",
+          "  #   }",
+          "  # ]",
+          "",
+          "  # Authorization#{authz_comment}",
+          "  #{authz_lib}      # Options: cancancan, pundit, rolify, nil",
+          "end"
+        ].join("\n") + "\n"
+      end
+
+      private
+
+      def detect_test_framework
+        rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+
+        return "rspec" if File.exist?(File.join(rails_root, ".rspec")) ||
+                          File.exist?(File.join(rails_root, "spec", "spec_helper.rb")) ||
+                          Dir.exist?(File.join(rails_root, "spec"))
+
+        return "minitest" if Dir.exist?(File.join(rails_root, "test")) ||
+                             File.exist?(File.join(rails_root, "test", "test_helper.rb"))
+
+        begin
+          if defined?(Bundler)
+            gemfile_specs = Bundler.load.specs
+            return "rspec" if gemfile_specs.any? { |spec| spec.name == "rspec-rails" }
+            return "minitest" if gemfile_specs.any? { |spec| spec.name == "minitest" }
+          end
+        rescue StandardError
+          # Fallback if Bundler isn't available
+        end
+
+        "minitest" # Default fallback
+      end
+
+      def detect_authentication_library
+        return unless defined?(Bundler)
+
+        begin
+          gemfile_specs = Bundler.load.specs
+          return "devise" if gemfile_specs.any? { |spec| spec.name == "devise" }
+          return "clearance" if gemfile_specs.any? { |spec| spec.name == "clearance" }
+          return "sorcery" if gemfile_specs.any? { |spec| spec.name == "sorcery" }
+        rescue StandardError
+          # Fallback if Bundler isn't available
+          nil
+        end
+
+        nil
+      end
+
+      def detect_authorization_library
+        return unless defined?(Bundler)
+
+        gemfile_specs = Bundler.load.specs
+        return "cancancan" if gemfile_specs.any? { |spec| spec.name == "cancancan" }
+        return "pundit" if gemfile_specs.any? { |spec| spec.name == "pundit" }
+        return "rolify" if gemfile_specs.any? { |spec| spec.name == "rolify" }
+
+        nil
+      end
+
+      def detect_factory_library
+        return "active_record" unless defined?(Bundler)
+
+        rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
+
+        # Check for fixtures in test/fixtures or spec/fixtures
+        test_fixtures_path = File.join(rails_root, "test", "fixtures")
+        spec_fixtures_path = File.join(rails_root, "spec", "fixtures")
+
+        return "fixtures" if Dir.exist?(test_fixtures_path) && !Dir.empty?(test_fixtures_path)
+
+        return "fixtures" if Dir.exist?(spec_fixtures_path) && !Dir.empty?(spec_fixtures_path)
+
+        gemfile_specs = Bundler.load.specs
+        return "factory_bot" if gemfile_specs.any? { |spec| spec.name.match(/factory_bot/) }
+        return "factory_girl" if gemfile_specs.any? { |spec| spec.name.match(/factory_girl/) }
+        return "fabrication" if gemfile_specs.any? { |spec| spec.name.match(/fabrication/) }
+        return "fabricator" if gemfile_specs.any? { |spec| spec.name.match(/fabricator/) }
+
+        "active_record"
+      rescue StandardError
+        # Fallback if Bundler isn't available
+        "active_record"
+      end
+
+      def generate_framework_config(framework)
+        if framework == "minitest"
+          {
+            "test_style" => "test_block", # Options: spec, unit, test_block
+            "setup_style" => true, # Options: true, false
+            "assertion_style" => "assert/refute", # Options: assert/refute, assert/assert_not, must/wont
+            "teardown_style" => false, # Options: true, false
+            "http_mock_library" => "webmock", # Options: webmock, vcr, httparty, none
+            "mock_library" => "minitest/mock" # Options: mocha, minitest/mock, rspec-mocks, none
+          }
+        else # rspec
+          {
+            "describe_style" => true, # Options: true, false
+            "context_style" => "context", # Options: context, describe
+            "it_style" => "it", # Options: it, specify
+            "before_style" => "before", # Options: before, setup
+            "after_style" => "after", # Options: after, teardown
+            "let_style" => true, # Options: true, false
+            "subject_style" => true, # Options: true, false
+            "mock_library" => "rspec-mocks", # Options: rspec-mocks, mocha, flexmock, none
+            "http_mock_library" => "webmock" # Options: webmock, vcr, httparty, none
+          }
+        end
+      end
+
+      def generate_framework_specific_config(framework, framework_config)
+        if framework == "minitest"
+            "  config.test_style = \"#{framework_config["test_style"]}\"           # Options: spec, unit, test_block\n" +
+            "  config.setup_style = #{framework_config["setup_style"]}                  # Options: true, false\n" +
+            "  config.assertion_style = \"#{framework_config["assertion_style"]}\"   # Options: assert/refute, assert/assert_not, must/wont\n" +
+            "  config.teardown_style = #{framework_config["teardown_style"]}              # Options: true, false"
+        else # rspec
+            "  config.describe_style = #{framework_config["describe_style"]}                  # Options: true, false\n" +
+            "  config.context_style = \"#{framework_config["context_style"]}\"                  # Options: context, describe\n" +
+            "  config.it_style = \"#{framework_config["it_style"]}\"                  # Options: it, specify\n" +
+            "  config.before_style = \"#{framework_config["before_style"]}\"                  # Options: before, setup\n" +
+            "  config.after_style = \"#{framework_config["after_style"]}\"                  # Options: after, teardown\n" +
+            "  config.let_style = #{framework_config["let_style"]}                  # Options: true, false\n" +
+            "  config.subject_style = #{framework_config["subject_style"]}                  # Options: true, false"
+        end
+      end
+    end
+  end
+end

data/lib/tng/analyzers/controller.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Tng
+  module Analyzers
+    class Controller
+      def self.files_in_dir(dir)
+        dir = File.join(Dir.pwd, "app/controllers") if dir.nil?
+        Tng::Analyzer::Controller.files_in_dir(dir.to_s)
+      end
+
+      def self.routes_for_controller(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        Tng::Analyzer::Controller.routes_for_controller(file_path)
+      end
+
+      def self.value_for_controller(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        Tng::Analyzer::Controller.parse_controller_file(file_path)
+      end
+
+      def self.parents_for_controller(controller)
+        raise "controller is required" if controller.nil?
+
+        path = controller[:path]
+        relative_path = path.gsub(%r{^.*app/controllers/}, "").gsub(".rb", "")
+        clean_controller_name = relative_path.split("/").map(&:camelize).join("::")
+
+        begin
+          Tng::Analyzer::Controller.parents_for_controller(clean_controller_name)
+        rescue NameError => e
+          puts "❌ Error analyzing controller #{clean_controller_name}: #{e.message}"
+          puts "   Path: #{path}"
+          puts "   This might be due to a syntax error in the controller file."
+          []
+        rescue StandardError => e
+          puts "❌ Error analyzing controller #{clean_controller_name}: #{e.message}"
+          puts "   Path: #{path}"
+          puts "   This might be due to a syntax error in the controller file."
+          []
+        end
+      end
+
+      def self.model_info_for_controller(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        Tng::Analyzer::Controller.model_info_for_controller(file_path)
+      end
+
+      def self.find_test_file_for_controller(controller_path)
+        controller_name = File.basename(controller_path, ".rb")
+        testing_framework = Tng.testing_framework
+        return [] if testing_framework.nil?
+
+        paths = if testing_framework.downcase == "rspec"
+                  [
+                    "spec/controllers/#{controller_name}_spec.rb",
+                    "spec/requests/#{controller_name}_spec.rb"
+                  ]
+                else
+                  [
+                    "test/controllers/#{controller_name}_test.rb",
+                    "test/functional/#{controller_name}_test.rb"
+                  ]
+                end
+
+        paths.select { |path| File.exist?(path) }
+      end
+
+      def self.read_test_file_for_controller(controller_path)
+        files = find_test_file_for_controller(controller_path)
+
+        files.map do |file_path|
+          {
+            path: file_path,
+            content: File.read(file_path)
+          }
+        end
+      end
+
+      def self.methods_for_controller(controller_name)
+        raise "controller_name is required" if controller_name.nil?
+
+        begin
+          # Load the controller class
+          controller_class = controller_name.constantize
+
+          # Get public instance methods (actions) excluding inherited ones
+          public_methods = controller_class.public_instance_methods(false)
+
+          # Filter to methods defined in this controller only
+          action_methods = public_methods.select do |method_name|
+            method = controller_class.instance_method(method_name)
+            method.owner == controller_class
+          end
+
+          # Return method info
+          action_methods.map do |method_name|
+            {
+              name: method_name.to_s
+            }
+          end
+        rescue NameError => e
+          puts "❌ Could not load controller class #{controller_name}: #{e.message}"
+          []
+        rescue StandardError => e
+          puts "❌ Error analyzing controller #{controller_name}: #{e.message}"
+          []
+        end
+      end
+    end
+  end
+end

data/lib/tng/analyzers/model.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Tng
+  module Analyzers
+    class Model
+      def self.files_in_dir(dir = nil)
+        dir = File.join(Dir.pwd, "app/models") if dir.nil?
+        Tng::Analyzer::Model.files_in_dir(dir.to_s)
+      end
+
+      def self.value_for_model(file_path)
+        raise "file_path is required" if file_path.nil?
+
+        Tng::Analyzer::Model.parse_model_file(file_path)
+      end
+
+      def self.read_test_file_for_model(model_path)
+        files = find_test_file_for_model(model_path)
+
+        files.map do |file_path|
+          {
+            path: file_path,
+            content: File.read(file_path)
+          }
+        end
+      end
+
+      def self.find_test_file_for_model(model_path)
+        model_name = File.basename(model_path, ".rb")
+        testing_framework = Tng.testing_framework
+        return [] if testing_framework.nil?
+
+        paths = if testing_framework.downcase == "rspec"
+                  [
+                    "spec/models/#{model_name}_spec.rb",
+                    "spec/requests/#{model_name}_spec.rb"
+                  ]
+                else
+                  [
+                    "test/models/#{model_name}_test.rb",
+                    "test/functional/#{model_name}_test.rb"
+                  ]
+                end
+
+        paths.select { |path| File.exist?(path) }
+      end
+
+      def self.model_connections(model)
+        raise "model is required" if model.nil?
+
+        file_path = model.is_a?(Hash) ? model[:path] : model
+        raise "model path is required" if file_path.nil?
+
+        Tng::Analyzer::Model.model_connections(file_path.to_s)
+      end
+
+      def self.methods_for_model(model_name)
+        raise "model_name is required" if model_name.nil?
+
+        begin
+          # Load the model class
+          model_class = model_name.constantize
+
+          instance_methods = model_class.public_instance_methods(false)
+          class_methods = model_class.public_methods(false) - Class.public_methods
+
+          model_file = model_class.const_source_location(model_class.name.split("::").last)&.first
+
+          model_methods = if model_file && File.exist?(model_file)
+                            source_code = File.read(model_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 = model_class.instance_method(method_name)
+                              next false unless method.owner == model_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
+
+          model_methods.map { |method_name| { name: method_name.to_s } }
+        rescue NameError => e
+          puts "❌ Could not load model class #{model_name}: #{e.message}"
+          []
+        rescue StandardError => e
+          puts "❌ Error analyzing model #{model_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
+    end
+  end
+end

data/lib/tng/analyzers/service.rb

@@ -0,0 +1,149 @@
+# 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