refactor(compiler): always preserve directory structure in output

Remove preserve_structure option and implement smart path handling:
- Single source_include: exclude source dir name from output
  (src/models/user.trb → build/models/user.rb)
- Multiple source_include: include source dir name in output
  (src/models/user.trb → build/src/models/user.rb)
- Files outside source directories: preserve relative path from cwd
  (external/foo.trb → build/external/foo.rb)

Add resolve_path helper to handle macOS symlink paths (/var vs /private/var).

Author: yhk1038

lib/t_ruby/cli.rb

@@ -105,7 +105,6 @@ def init_project
           output:
             ruby_dir: #{build_dir}
             # rbs_dir: sig  # Optional: separate directory for .rbs files
-            preserve_structure: true
             # clean_before_build: false
 
           compiler:

lib/t_ruby/compiler.rb

@@ -38,29 +38,27 @@ def compile(input_path)
       # Transform source to Ruby code
       output = @use_ir ? transform_with_ir(source, parser) : transform_legacy(source, parse_result)
 
-      out_dir = @config.out_dir
-      FileUtils.mkdir_p(out_dir)
-
-      base_filename = File.basename(input_path, ".trb")
-      output_path = File.join(out_dir, "#{base_filename}.rb")
+      # Compute output path (respects preserve_structure setting)
+      output_path = compute_output_path(input_path, @config.ruby_dir, ".rb")
+      FileUtils.mkdir_p(File.dirname(output_path))
 
       File.write(output_path, output)
 
       # Generate .rbs file if enabled in config
       if @config.compiler["generate_rbs"]
-        rbs_dir = @config.rbs_dir
-        FileUtils.mkdir_p(rbs_dir)
+        rbs_path = compute_output_path(input_path, @config.rbs_dir, ".rbs")
+        FileUtils.mkdir_p(File.dirname(rbs_path))
         if @use_ir && parser.ir_program
-          generate_rbs_from_ir(base_filename, rbs_dir, parser.ir_program)
+          generate_rbs_from_ir_to_path(rbs_path, parser.ir_program)
         else
-          generate_rbs_file(base_filename, rbs_dir, parse_result)
+          generate_rbs_file_to_path(rbs_path, parse_result)
         end
       end
 
       # Generate .d.trb file if enabled in config (legacy support)
       # TODO: Add compiler.generate_dtrb option in future
       if @config.compiler.key?("generate_dtrb") && @config.compiler["generate_dtrb"]
-        generate_dtrb_file(input_path, out_dir)
+        generate_dtrb_file(input_path, @config.ruby_dir)
       end
 
       output_path
@@ -161,8 +159,70 @@ def optimization_stats
       @optimizer&.stats
     end
 
+    # Compute output path for a source file
+    # @param input_path [String] path to source file
+    # @param output_dir [String] base output directory
+    # @param new_extension [String] new file extension (e.g., ".rb", ".rbs")
+    # @return [String] computed output path (always preserves directory structure)
+    def compute_output_path(input_path, output_dir, new_extension)
+      relative = compute_relative_path(input_path)
+      base = relative.sub(/\.[^.]+$/, new_extension)
+      File.join(output_dir, base)
+    end
+
+    # Compute relative path from source directory
+    # @param input_path [String] path to source file
+    # @return [String] relative path preserving directory structure
+    def compute_relative_path(input_path)
+      # Use realpath to resolve symlinks (e.g., /var vs /private/var on macOS)
+      absolute_input = resolve_path(input_path)
+      source_dirs = @config.source_include
+
+      # Check if file is inside any source_include directory
+      if source_dirs.size > 1
+        # Multiple source directories: include the source dir name in output
+        # src/models/user.trb → src/models/user.trb
+        source_dirs.each do |src_dir|
+          absolute_src = resolve_path(src_dir)
+          next unless absolute_input.start_with?("#{absolute_src}/")
+
+          # Return path relative to parent of source dir (includes src dir name)
+          parent_of_src = File.dirname(absolute_src)
+          return absolute_input.sub("#{parent_of_src}/", "")
+        end
+      else
+        # Single source directory: exclude the source dir name from output
+        # src/models/user.trb → models/user.trb
+        src_dir = source_dirs.first
+        if src_dir
+          absolute_src = resolve_path(src_dir)
+          if absolute_input.start_with?("#{absolute_src}/")
+            return absolute_input.sub("#{absolute_src}/", "")
+          end
+        end
+      end
+
+      # File outside source directories: use path relative to current working directory
+      # external/foo.trb → external/foo.trb
+      cwd = resolve_path(".")
+      if absolute_input.start_with?("#{cwd}/")
+        return absolute_input.sub("#{cwd}/", "")
+      end
+
+      # Absolute path from outside cwd: use basename only
+      File.basename(input_path)
+    end
+
     private
 
+    # Resolve path to absolute path, following symlinks
+    # Falls back to expand_path if realpath fails (e.g., file doesn't exist yet)
+    def resolve_path(path)
+      File.realpath(path)
+    rescue Errno::ENOENT
+      File.expand_path(path)
+    end
+
     def setup_declaration_paths
       # Add default declaration paths
       @declaration_loader.add_search_path(@config.out_dir)
@@ -197,30 +257,29 @@ def transform_legacy(source, parse_result)
       end
     end
 
-    # Generate RBS from IR
-    def generate_rbs_from_ir(base_filename, out_dir, ir_program)
+    # Generate RBS from IR to a specific path
+    def generate_rbs_from_ir_to_path(rbs_path, ir_program)
       generator = IR::RBSGenerator.new
       rbs_content = generator.generate(ir_program)
-
-      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
       File.write(rbs_path, rbs_content) unless rbs_content.strip.empty?
     end
 
-    # Legacy RBS generation
-    def generate_rbs_file(base_filename, out_dir, parse_result)
+    # Legacy RBS generation to a specific path
+    def generate_rbs_file_to_path(rbs_path, parse_result)
       generator = RBSGenerator.new
       rbs_content = generator.generate(
         parse_result[:functions] || [],
         parse_result[:type_aliases] || []
       )
-
-      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
       File.write(rbs_path, rbs_content) unless rbs_content.empty?
     end
 
     def generate_dtrb_file(input_path, out_dir)
+      dtrb_path = compute_output_path(input_path, out_dir, DeclarationGenerator::DECLARATION_EXTENSION)
+      FileUtils.mkdir_p(File.dirname(dtrb_path))
+
       generator = DeclarationGenerator.new
-      generator.generate_file(input_path, out_dir)
+      generator.generate_file_to_path(input_path, dtrb_path)
     end
 
     # Copy .rb file to output directory and generate .rbs signature
@@ -229,28 +288,25 @@ def copy_ruby_file(input_path)
         raise ArgumentError, "File not found: #{input_path}"
       end
 
-      out_dir = @config.out_dir
-      FileUtils.mkdir_p(out_dir)
-
-      base_filename = File.basename(input_path, ".rb")
-      output_path = File.join(out_dir, "#{base_filename}.rb")
+      # Compute output path (respects preserve_structure setting)
+      output_path = compute_output_path(input_path, @config.ruby_dir, ".rb")
+      FileUtils.mkdir_p(File.dirname(output_path))
 
       # Copy the .rb file to output directory
       FileUtils.cp(input_path, output_path)
 
       # Generate .rbs file if enabled in config
       if @config.compiler["generate_rbs"]
-        rbs_dir = @config.rbs_dir
-        FileUtils.mkdir_p(rbs_dir)
-        generate_rbs_from_ruby(base_filename, rbs_dir, input_path)
+        rbs_path = compute_output_path(input_path, @config.rbs_dir, ".rbs")
+        FileUtils.mkdir_p(File.dirname(rbs_path))
+        generate_rbs_from_ruby_to_path(rbs_path, input_path)
       end
 
       output_path
     end
 
-    # Generate RBS from Ruby file using rbs prototype
-    def generate_rbs_from_ruby(base_filename, out_dir, input_path)
-      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
+    # Generate RBS from Ruby file using rbs prototype to a specific path
+    def generate_rbs_from_ruby_to_path(rbs_path, input_path)
       result = `rbs prototype rb #{input_path} 2>/dev/null`
       File.write(rbs_path, result) unless result.strip.empty?
     end

lib/t_ruby/config.rb

@@ -19,7 +19,6 @@ class Config
       "output" => {
         "ruby_dir" => "build",
         "rbs_dir" => nil,
-        "preserve_structure" => true,
         "clean_before_build" => false,
       },
       "compiler" => {
@@ -72,12 +71,6 @@ def rbs_dir
       @output["rbs_dir"] || ruby_dir
     end
 
-    # Check if source directory structure should be preserved in output
-    # @return [Boolean] true if structure should be preserved
-    def preserve_structure?
-      @output["preserve_structure"] != false
-    end
-
     # Check if output directory should be cleaned before build
     # @return [Boolean] true if should clean before build
     def clean_before_build?

lib/t_ruby/declaration_generator.rb

@@ -64,6 +64,23 @@ def generate_file(input_path, output_dir = nil)
       output_path
     end
 
+    # Generate declaration file to a specific output path
+    def generate_file_to_path(input_path, output_path)
+      unless File.exist?(input_path)
+        raise ArgumentError, "File not found: #{input_path}"
+      end
+
+      unless input_path.end_with?(".trb")
+        raise ArgumentError, "Expected .trb file, got: #{input_path}"
+      end
+
+      source = File.read(input_path)
+      content = generate(source)
+
+      File.write(output_path, content)
+      output_path
+    end
+
     private
 
     def generate_type_alias(type_alias)

spec/e2e/config_behavior_spec.rb

@@ -88,17 +88,16 @@ def calculate(x: Integer, y: Integer): Integer
     end
   end
 
-  describe "output.preserve_structure" do
-    context "when true (default)" do
-      it "preserves directory structure in output" do
+  describe "directory structure preservation" do
+    context "with single source_include directory" do
+      it "excludes source dir name from output path" do
         Dir.chdir(tmpdir) do
           create_config_file(<<~YAML)
             source:
               include:
                 - src
             output:
               ruby_dir: build
-              preserve_structure: true
           YAML
 
           create_trb_file("src/models/user.trb", <<~TRB)
@@ -111,37 +110,36 @@ def find_user(id: Integer): String
           compiler = TRuby::Compiler.new(config)
           compiler.compile(File.join(tmpdir, "src/models/user.trb"))
 
-          # NOTE: Current compiler puts files in root of build dir
-          # This test documents expected behavior, not current implementation
-          expect(File.exist?(File.join(tmpdir, "build/user.rb"))).to be true
+          # Single source_include: src/models/user.trb → build/models/user.rb
+          expect(File.exist?(File.join(tmpdir, "build/models/user.rb"))).to be true
         end
       end
     end
 
-    # NOTE: preserve_structure: false is not yet implemented
-    context "when false" do
-      xit "flattens output to single directory" do
+    context "with multiple source_include directories" do
+      it "includes source dir name in output path" do
         Dir.chdir(tmpdir) do
           create_config_file(<<~YAML)
             source:
               include:
                 - src
+                - lib
             output:
               ruby_dir: build
-              preserve_structure: false
           YAML
 
-          create_trb_file("src/deep/nested/file.trb", <<~TRB)
-            def nested_func: void
-              puts "hello"
+          create_trb_file("src/models/user.trb", <<~TRB)
+            def find_user(id: Integer): String
+              "user"
             end
           TRB
 
           config = TRuby::Config.new
           compiler = TRuby::Compiler.new(config)
-          compiler.compile(File.join(tmpdir, "src/deep/nested/file.trb"))
+          compiler.compile(File.join(tmpdir, "src/models/user.trb"))
 
-          expect(File.exist?(File.join(tmpdir, "build/file.rb"))).to be true
+          # Multiple source_include: src/models/user.trb → build/src/models/user.rb
+          expect(File.exist?(File.join(tmpdir, "build/src/models/user.rb"))).to be true
         end
       end
     end

spec/t_ruby/cli_init_spec.rb

@@ -27,7 +27,6 @@
 
         expect(config["output"]).to be_a(Hash)
         expect(config["output"]["ruby_dir"]).to eq("build")
-        expect(config["output"]["preserve_structure"]).to eq(true)
 
         expect(config["compiler"]).to be_a(Hash)
         expect(config["compiler"]["generate_rbs"]).to eq(true)

spec/t_ruby/cli_spec.rb

@@ -117,6 +117,8 @@
           File.write(input_file, "def hello; end")
 
           allow_any_instance_of(TRuby::Config).to receive(:out_dir).and_return(tmpdir)
+          allow_any_instance_of(TRuby::Config).to receive(:ruby_dir).and_return(tmpdir)
+          allow_any_instance_of(TRuby::Config).to receive(:source_include).and_return([tmpdir])
 
           cli = TRuby::CLI.new([input_file])
           capture_stdout { cli.run }