t-ruby 0.0.35 → 0.0.37

data/lib/t_ruby/compiler.rb

@@ -38,29 +38,27 @@ module TRuby
       # 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
@@ -98,19 +96,19 @@ module TRuby
       {
         ruby: ruby_output,
         rbs: rbs_output,
-        errors: []
+        errors: [],
       }
     rescue ParseError => e
       {
         ruby: "",
         rbs: "",
-        errors: [e.message]
+        errors: [e.message],
       }
     rescue StandardError => e
       {
         ruby: "",
         rbs: "",
-        errors: ["Compilation error: #{e.message}"]
+        errors: ["Compilation error: #{e.message}"],
       }
     end
 
@@ -161,8 +159,70 @@ module TRuby
       @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 @@ module TRuby
       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 @@ module TRuby
         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
@@ -273,20 +329,20 @@ module TRuby
       result = source.dup
 
       # Collect type alias names to remove
-      type_alias_names = program.declarations
-        .select { |d| d.is_a?(IR::TypeAlias) }
-        .map(&:name)
+      program.declarations
+             .select { |d| d.is_a?(IR::TypeAlias) }
+             .map(&:name)
 
       # Collect interface names to remove
-      interface_names = program.declarations
-        .select { |d| d.is_a?(IR::Interface) }
-        .map(&:name)
+      program.declarations
+             .select { |d| d.is_a?(IR::Interface) }
+             .map(&:name)
 
       # Remove type alias definitions
-      result = result.gsub(/^\s*type\s+\w+\s*=\s*.+?$\n?/, '')
+      result = result.gsub(/^\s*type\s+\w+\s*=\s*.+?$\n?/, "")
 
       # Remove interface definitions (multi-line)
-      result = result.gsub(/^\s*interface\s+\w+.*?^\s*end\s*$/m, '')
+      result = result.gsub(/^\s*interface\s+\w+.*?^\s*end\s*$/m, "")
 
       # Remove parameter type annotations using IR info
       # Enhanced: Handle complex types (generics, unions, etc.)
@@ -296,9 +352,7 @@ module TRuby
       result = erase_return_types(result)
 
       # Clean up extra blank lines
-      result = result.gsub(/\n{3,}/, "\n\n")
-
-      result
+      result.gsub(/\n{3,}/, "\n\n")
     end
 
     private
@@ -308,11 +362,11 @@ module TRuby
       result = source.dup
 
       # Match function definitions and remove type annotations from parameters
-      result.gsub!(/^(\s*def\s+\w+\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |match|
-        indent = $1
-        params = $2
-        close_paren = $3
-        ending = $4
+      result.gsub!(/^(\s*def\s+\w+\s*\()([^)]+)(\)\s*)(?::\s*[^\n]+)?(\s*$)/) do |_match|
+        indent = ::Regexp.last_match(1)
+        params = ::Regexp.last_match(2)
+        close_paren = ::Regexp.last_match(3)
+        ending = ::Regexp.last_match(4)
 
         # Remove type annotations from each parameter
         cleaned_params = remove_param_types(params)
@@ -340,7 +394,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             params << clean_param(current.strip)
             current = ""
           else
@@ -358,7 +412,7 @@ module TRuby
     # Clean a single parameter (remove type annotation)
     def clean_param(param)
       # Match: name: Type or name
-      if match = param.match(/^(\w+)\s*:/)
+      if (match = param.match(/^(\w+)\s*:/))
         match[1]
       else
         param
@@ -370,7 +424,7 @@ module TRuby
       result = source.dup
 
       # Remove return type: ): Type or ): Type<Foo> etc.
-      result.gsub!(/\)\s*:\s*[^\n]+?(?=\s*$)/m) do |match|
+      result.gsub!(/\)\s*:\s*[^\n]+?(?=\s*$)/m) do |_match|
         ")"
       end
 

data/lib/t_ruby/config.rb

@@ -14,13 +14,12 @@ module TRuby
       "source" => {
         "include" => ["src"],
         "exclude" => [],
-        "extensions" => [".trb"]
+        "extensions" => [".trb"],
       },
       "output" => {
         "ruby_dir" => "build",
         "rbs_dir" => nil,
-        "preserve_structure" => true,
-        "clean_before_build" => false
+        "clean_before_build" => false,
       },
       "compiler" => {
         "strictness" => "standard",
@@ -30,15 +29,15 @@ module TRuby
         "checks" => {
           "no_implicit_any" => false,
           "no_unused_vars" => false,
-          "strict_nil" => false
-        }
+          "strict_nil" => false,
+        },
       },
       "watch" => {
         "paths" => [],
         "debounce" => 100,
         "clear_screen" => false,
-        "on_success" => nil
-      }
+        "on_success" => nil,
+      },
     }.freeze
 
     # Legacy keys for migration detection
@@ -72,12 +71,6 @@ module TRuby
       @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?
@@ -249,7 +242,7 @@ module TRuby
       value = strictness
       return if VALID_STRICTNESS.include?(value)
 
-      raise ConfigError, "Invalid compiler.strictness: '#{value}'. Must be one of: #{VALID_STRICTNESS.join(', ')}"
+      raise ConfigError, "Invalid compiler.strictness: '#{value}'. Must be one of: #{VALID_STRICTNESS.join(", ")}"
     end
 
     def load_raw_config(config_path)
@@ -308,8 +301,8 @@ module TRuby
       result = deep_dup(DEFAULT_CONFIG)
 
       # Migrate emit -> compiler.generate_rbs
-      if raw_config["emit"]
-        result["compiler"]["generate_rbs"] = raw_config["emit"]["rbs"] if raw_config["emit"].key?("rbs")
+      if raw_config["emit"]&.key?("rbs")
+        result["compiler"]["generate_rbs"] = raw_config["emit"]["rbs"]
       end
 
       # Migrate paths -> source.include and output.ruby_dir
@@ -344,8 +337,12 @@ module TRuby
     end
 
     def deep_dup(hash)
-      hash.each_with_object({}) do |(key, value), result|
-        result[key] = value.is_a?(Hash) ? deep_dup(value) : (value.is_a?(Array) ? value.dup : value)
+      hash.transform_values do |value|
+        if value.is_a?(Hash)
+          deep_dup(value)
+        else
+          (value.is_a?(Array) ? value.dup : value)
+        end
       end
     end
 

data/lib/t_ruby/constraint_checker.rb

@@ -42,7 +42,7 @@ module TRuby
     end
 
     def satisfied?(value_type)
-      @left_type == value_type || @right_type == value_type
+      [@left_type, @right_type].include?(value_type)
     end
   end
 
@@ -62,6 +62,7 @@ module TRuby
       return false unless value.is_a?(Numeric)
       return false if @min && value < @min
       return false if @max && value > @max
+
       true
     end
 
@@ -78,6 +79,7 @@ module TRuby
       return "#{@min}..#{@max}" if @min && @max
       return ">= #{@min}" if @min
       return "<= #{@max}" if @max
+
       ""
     end
   end
@@ -94,6 +96,7 @@ module TRuby
 
     def satisfied?(value)
       return false unless value.is_a?(String)
+
       @pattern.match?(value)
     end
 
@@ -145,10 +148,12 @@ module TRuby
 
     def satisfied?(value)
       return false unless value.respond_to?(:length)
+
       len = value.length
       return len == @exact_length if @exact_length
       return false if @min_length && len < @min_length
       return false if @max_length && len > @max_length
+
       true
     end
 
@@ -167,6 +172,7 @@ module TRuby
 
     def build_condition
       return "length == #{@exact_length}" if @exact_length
+
       parts = []
       parts << "length >= #{@min_length}" if @min_length
       parts << "length <= #{@max_length}" if @max_length
@@ -187,7 +193,7 @@ module TRuby
     def register(name, base_type:, constraints: [])
       @constraints[name] = {
         base_type: base_type,
-        constraints: constraints
+        constraints: constraints,
       }
     end
 
@@ -213,7 +219,7 @@ module TRuby
         return {
           name: name,
           base_type: base_type,
-          constraints: [BoundsConstraint.new(subtype: name, supertype: base_type)]
+          constraints: [BoundsConstraint.new(subtype: name, supertype: base_type)],
         }
       end
 
@@ -325,8 +331,8 @@ module TRuby
       end
 
       # Pattern: /regex/
-      if condition.match?(/^\/(.+)\/$/)
-        match = condition.match(/^\/(.+)\/$/)
+      if condition.match?(%r{^/(.+)/$})
+        match = condition.match(%r{^/(.+)/$})
         constraints << PatternConstraint.new(base_type: base_type, pattern: match[1])
       end
 
@@ -353,7 +359,7 @@ module TRuby
       # Predicate: positive?, negative?, empty?, etc.
       if condition.match?(/^(\w+)\?$/)
         match = condition.match(/^(\w+)\?$/)
-        constraints << PredicateConstraint.new(base_type: base_type, predicate: "#{match[1]}?".to_sym)
+        constraints << PredicateConstraint.new(base_type: base_type, predicate: :"#{match[1]}?")
       end
 
       constraints
@@ -367,7 +373,7 @@ module TRuby
       when "Numeric" then value.is_a?(Numeric)
       when "Array" then value.is_a?(Array)
       when "Hash" then value.is_a?(Hash)
-      when "Boolean" then value == true || value == false
+      when "Boolean" then [true, false].include?(value)
       when "Symbol" then value.is_a?(Symbol)
       else true # Unknown types pass through
       end
@@ -388,7 +394,7 @@ module TRuby
       @types[name] = {
         base_type: base_type,
         constraints: constraints,
-        defined_at: caller_locations(1, 1).first
+        defined_at: caller_locations(1, 1).first,
       }
       @checker.register(name, base_type: base_type, constraints: constraints)
     end

data/lib/t_ruby/declaration_generator.rb

@@ -64,6 +64,23 @@ module TRuby
       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)
@@ -195,7 +212,7 @@ module TRuby
       {
         type_aliases: @type_aliases,
         interfaces: @interfaces,
-        functions: @functions
+        functions: @functions,
       }
     end
 
@@ -230,13 +247,13 @@ module TRuby
 
       @search_paths.each do |path|
         full_path = File.join(path, file_name)
-        if File.exist?(full_path) && !@loaded_files.include?(full_path)
-          parser = DeclarationParser.new
-          parser.parse_file(full_path)
-          @loaded_declarations.merge(parser)
-          @loaded_files.add(full_path)
-          return true
-        end
+        next unless File.exist?(full_path) && !@loaded_files.include?(full_path)
+
+        parser = DeclarationParser.new
+        parser.parse_file(full_path)
+        @loaded_declarations.merge(parser)
+        @loaded_files.add(full_path)
+        return true
       end
 
       false