konpeito 0.1.0

data/lib/konpeito/cli/test_command.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Commands
+    # Test command - run tests with Minitest
+    class TestCommand < BaseCommand
+      def self.command_name
+        "test"
+      end
+
+      def self.description
+        "Run tests (Minitest integration)"
+      end
+
+      def run
+        parse_options!
+
+        test_files = find_test_files
+
+        if test_files.empty?
+          puts "No test files found matching pattern: #{options[:pattern]}"
+          return
+        end
+
+        target = options[:target] || config.target
+
+        if target == :jvm
+          run_jvm_tests(test_files)
+        else
+          if options[:compile_first]
+            compile_source_files
+          end
+          run_tests(test_files)
+        end
+      end
+
+      protected
+
+      def default_options
+        {
+          verbose: false,
+          color: $stderr.tty?,
+          pattern: config.test_pattern,
+          compile_first: false,
+          name_pattern: nil,
+          target: nil,
+          classpath: nil
+        }
+      end
+
+      def setup_option_parser(opts)
+        opts.on("-p", "--pattern PATTERN", "Test file pattern (default: test/**/*_test.rb)") do |pattern|
+          options[:pattern] = pattern
+        end
+
+        opts.on("-n", "--name PATTERN", "Run tests matching name pattern") do |pattern|
+          options[:name_pattern] = pattern
+        end
+
+        opts.on("--compile", "Compile source files before running tests") do
+          options[:compile_first] = true
+        end
+
+        opts.on("--target TARGET", %i[native jvm], "Target platform (native, jvm)") do |target|
+          options[:target] = target
+        end
+
+        opts.on("--classpath PATH", "Add external JARs/directories to classpath (JVM only)") do |path|
+          options[:classpath] = path
+        end
+
+        super
+      end
+
+      def banner
+        <<~BANNER.chomp
+          Usage: konpeito test [options] [test_files...]
+
+          Examples:
+            konpeito test                              Run all tests
+            konpeito test test/main_test.rb            Run specific test file
+            konpeito test -n test_hello                Run matching test name
+            konpeito test --target jvm                 Run JVM tests
+        BANNER
+      end
+
+      private
+
+      def find_test_files
+        if args.empty?
+          Dir.glob(options[:pattern])
+        else
+          args.select { |f| File.exist?(f) }
+        end
+      end
+
+      def compile_source_files
+        puts_verbose "Compiling source files..."
+
+        src_files = Dir.glob("src/**/*.rb")
+        src_files.each do |source_file|
+          puts_verbose "  Compiling #{source_file}..."
+          begin
+            output_file = default_output_name(source_file)
+            compiler = Compiler.new(
+              source_file: source_file,
+              output_file: output_file,
+              format: :cruby_ext,
+              verbose: options[:verbose],
+              rbs_paths: config.rbs_paths,
+              require_paths: config.require_paths
+            )
+            compiler.compile
+          rescue Konpeito::Error => e
+            $stderr.puts "Warning: Failed to compile #{source_file}: #{e.message}"
+          end
+        end
+      end
+
+      def run_jvm_tests(test_files)
+        require "tmpdir"
+        require "fileutils"
+
+        passed = 0
+        failed = 0
+        errors = 0
+
+        # Build classpath
+        classpath_parts = []
+        cp = options[:classpath] || config.jvm_classpath
+        classpath_parts << cp unless cp.empty?
+        lib_jars = Dir.glob("lib/*.jar")
+        classpath_parts << lib_jars.join(Platform.classpath_separator) unless lib_jars.empty?
+        classpath = classpath_parts.reject(&:empty?).join(Platform.classpath_separator)
+
+        puts "Running #{test_files.size} JVM test file(s)..."
+        puts ""
+
+        test_files.each do |test_file|
+          puts_verbose "Compiling #{test_file}..."
+
+          Dir.mktmpdir("konpeito-test") do |tmpdir|
+            jar_path = File.join(tmpdir, "test.jar")
+
+            begin
+              # Compile to JAR
+              build_args = ["--target", "jvm", "-o", jar_path]
+              build_args += ["--classpath", classpath] unless classpath.empty?
+              config.rbs_paths.each { |p| build_args << "--rbs" << p }
+              build_args << test_file
+
+              Commands::BuildCommand.new(build_args, config: config).run
+
+              # Run the JAR
+              java_cmd = find_java
+              run_cmd = if classpath.empty?
+                [java_cmd, "-jar", jar_path]
+              else
+                main_class = File.basename(test_file, ".rb").split("_").map(&:capitalize).join
+                cp = "#{jar_path}#{Platform.classpath_separator}#{classpath}"
+                [java_cmd, "-cp", cp, main_class]
+              end
+
+              output = `#{run_cmd.map { |s| s.include?(" ") ? "\"#{s}\"" : s }.join(" ")} 2>&1`
+
+              # Parse PASS:/FAIL: from output
+              output.each_line do |line|
+                line = line.strip
+                if line.start_with?("PASS:")
+                  passed += 1
+                  puts "  \e[32m#{line}\e[0m" if options[:color]
+                  puts "  #{line}" unless options[:color]
+                elsif line.start_with?("FAIL:")
+                  failed += 1
+                  puts "  \e[31m#{line}\e[0m" if options[:color]
+                  puts "  #{line}" unless options[:color]
+                end
+              end
+            rescue => e
+              errors += 1
+              $stderr.puts "  ERROR: #{test_file}: #{e.message}"
+            end
+          end
+        end
+
+        # Summary
+        puts ""
+        total = passed + failed
+        summary = "#{total} assertions, #{passed} passed, #{failed} failed"
+        summary += ", #{errors} errors" if errors > 0
+
+        if failed > 0 || errors > 0
+          puts options[:color] ? "\e[31m#{summary}\e[0m" : summary
+          exit 1
+        else
+          puts options[:color] ? "\e[32m#{summary}\e[0m" : summary
+        end
+      end
+
+      def find_java
+        java_home = config.jvm_java_home
+        java_home = ENV["JAVA_HOME"] || Platform.default_java_home if java_home.empty?
+        java_path = File.join(java_home, "bin", "java")
+        return java_path if File.exist?(java_path)
+
+        java_in_path = Platform.find_executable("java")
+        return java_in_path if java_in_path
+
+        error("Java not found. Install Java 21+: #{Platform.java_install_hint}")
+      end
+
+      def run_tests(test_files)
+        puts_verbose "Running #{test_files.size} test file(s)..."
+
+        # Build minitest command
+        cmd = ["ruby"]
+
+        # Add load paths
+        cmd << "-I" << "lib"
+        cmd << "-I" << "test"
+        cmd << "-I" << "src" if Dir.exist?("src")
+
+        # Require minitest
+        cmd << "-rminitest/autorun"
+
+        # Add name filter if specified
+        if options[:name_pattern]
+          cmd << "-e" << "Minitest.run_with_autorun([])"
+          cmd << "--" << "--name" << "/#{options[:name_pattern]}/"
+        end
+
+        # Add test files
+        test_files.each { |f| cmd << "-r" << "./#{f}" }
+
+        # Add final execution trigger if no name pattern
+        unless options[:name_pattern]
+          cmd << "-e" << ""
+        end
+
+        puts_verbose "Running: #{cmd.join(' ')}"
+
+        # Execute tests
+        success = system(*cmd)
+        exit(success ? 0 : 1)
+      end
+    end
+  end
+end

data/lib/konpeito/cli/watch_command.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Commands
+    # Watch command - watch for file changes and recompile
+    class WatchCommand < BaseCommand
+      def self.command_name
+        "watch"
+      end
+
+      def self.description
+        "Watch for file changes and recompile automatically"
+      end
+
+      def run
+        parse_options!
+
+        unless listen_available?
+          error("The 'listen' gem is required for watch mode. Install it with 'gem install listen'.")
+        end
+
+        require "listen"
+
+        @source_file = args.first
+        if @source_file && !File.exist?(@source_file)
+          error("File not found: #{@source_file}")
+        end
+
+        start_watching
+      end
+
+      protected
+
+      def default_options
+        {
+          verbose: false,
+          color: $stderr.tty?,
+          output: config.build_output,
+          format: config.build_format,
+          paths: config.watch_paths,
+          extensions: config.watch_extensions,
+          clear: true
+        }
+      end
+
+      def setup_option_parser(opts)
+        opts.on("-o", "--output FILE", "Output file name") do |file|
+          options[:output] = file
+        end
+
+        opts.on("-w", "--watch PATH", "Additional paths to watch (can be used multiple times)") do |path|
+          options[:paths] << path
+        end
+
+        opts.on("--no-clear", "Do not clear screen before each rebuild") do
+          options[:clear] = false
+        end
+
+        super
+      end
+
+      def banner
+        <<~BANNER.chomp
+          Usage: konpeito watch [options] [source.rb]
+
+          Examples:
+            konpeito watch src/main.rb                 Watch and recompile
+            konpeito watch -w lib src/main.rb          Watch additional paths
+        BANNER
+      end
+
+      private
+
+      def listen_available?
+        require "listen"
+        true
+      rescue LoadError
+        false
+      end
+
+      def start_watching
+        watch_paths = options[:paths].select { |p| Dir.exist?(p) }
+
+        if watch_paths.empty?
+          watch_paths = ["."]
+        end
+
+        timestamp = Time.now.strftime("%H:%M:%S")
+        emit("Watching", "#{watch_paths.join(', ')} [#{options[:extensions].join(', ')}]")
+        $stderr.puts ""
+
+        # Initial build
+        if @source_file
+          rebuild
+        end
+
+        # Start watching
+        extensions_pattern = /\.(#{options[:extensions].join('|')})$/
+
+        listener = Listen.to(*watch_paths) do |modified, added, removed|
+          changed_files = (modified + added + removed).select { |f| f.match?(extensions_pattern) }
+
+          unless changed_files.empty?
+            $stderr.puts ""
+            changed_files.each do |f|
+              emit("Changed", File.basename(f))
+            end
+            rebuild
+          end
+        end
+
+        listener.start
+
+        # Keep running
+        begin
+          sleep
+        rescue Interrupt
+          $stderr.puts ""
+          emit("Stopped", "watch mode")
+          listener.stop
+        end
+      end
+
+      def rebuild
+        clear_screen if options[:clear]
+
+        if @source_file
+          compile_single(@source_file)
+        else
+          compile_all
+        end
+      end
+
+      def compile_single(source_file)
+        output_file = options[:output] || default_output_name(source_file, format: options[:format])
+
+        emit("Compiling", "#{source_file} (native)")
+
+        compiler = Compiler.new(
+          source_file: source_file,
+          output_file: output_file,
+          format: options[:format],
+          verbose: options[:verbose],
+          rbs_paths: config.rbs_paths,
+          require_paths: config.require_paths,
+          incremental: true
+        )
+
+        compiler.compile
+        display_diagnostics(compiler.diagnostics)
+
+        if compiler.diagnostics.any?(&:error?)
+          error_count = compiler.diagnostics.count(&:error?)
+          emit_error("Failed", "with #{error_count} error(s)")
+        else
+          stats = compiler.compile_stats
+          if stats
+            duration_str = "%.2fs" % stats.duration_s
+            emit("Finished", "in #{duration_str} -> #{output_file}")
+          end
+        end
+      rescue Konpeito::Error => e
+        $stderr.puts "Error: #{e.message}"
+        emit_error("Failed", "build error")
+      end
+
+      def compile_all
+        src_files = Dir.glob("src/**/*.rb")
+
+        if src_files.empty?
+          puts "No source files found in src/"
+          return
+        end
+
+        success_count = 0
+        error_count = 0
+
+        src_files.each do |source_file|
+          begin
+            output_file = default_output_name(source_file, format: options[:format])
+            compiler = Compiler.new(
+              source_file: source_file,
+              output_file: output_file,
+              format: options[:format],
+              verbose: options[:verbose],
+              rbs_paths: config.rbs_paths,
+              require_paths: config.require_paths,
+              incremental: true
+            )
+            compiler.compile
+
+            if compiler.diagnostics.any?(&:error?)
+              display_diagnostics(compiler.diagnostics)
+              error_count += 1
+            else
+              success_count += 1
+            end
+          rescue Konpeito::Error => e
+            $stderr.puts "Error compiling #{source_file}: #{e.message}"
+            error_count += 1
+          end
+        end
+
+        puts "Build complete: #{success_count} succeeded, #{error_count} failed"
+      end
+
+      def clear_screen
+        print "\e[2J\e[H"
+      end
+    end
+  end
+end