t-ruby 0.0.35 → 0.0.36

data/lib/t_ruby/config.rb

@@ -14,13 +14,13 @@ 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 +30,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
@@ -249,7 +249,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 +308,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 +344,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

@@ -195,7 +195,7 @@ module TRuby
       {
         type_aliases: @type_aliases,
         interfaces: @interfaces,
-        functions: @functions
+        functions: @functions,
       }
     end
 
@@ -230,13 +230,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

data/lib/t_ruby/doc_generator.rb

@@ -14,7 +14,7 @@ module TRuby
         types: {},
         interfaces: {},
         functions: {},
-        modules: {}
+        modules: {},
       }
       @parser = nil
     end
@@ -84,7 +84,7 @@ module TRuby
         md << ""
 
         if info[:type_params]&.any?
-          md << "**Type Parameters:** `<#{info[:type_params].join(', ')}>`"
+          md << "**Type Parameters:** `<#{info[:type_params].join(", ")}>`"
           md << ""
         end
 
@@ -94,7 +94,7 @@ module TRuby
           md << "| Name | Type | Description |"
           md << "|------|------|-------------|"
           info[:members].each do |member|
-            md << "| `#{member[:name]}` | `#{member[:type]}` | #{member[:description] || '-'} |"
+            md << "| `#{member[:name]}` | `#{member[:type]}` | #{member[:description] || "-"} |"
           end
           md << ""
         end
@@ -114,9 +114,9 @@ module TRuby
 
         # Signature
         params = info[:params]&.map { |p| "#{p[:name]}: #{p[:type]}" }&.join(", ") || ""
-        type_params = info[:type_params]&.any? ? "<#{info[:type_params].join(', ')}>" : ""
+        type_params = info[:type_params]&.any? ? "<#{info[:type_params].join(", ")}>" : ""
         md << "```ruby"
-        md << "def #{name}#{type_params}(#{params}): #{info[:return_type] || 'void'}"
+        md << "def #{name}#{type_params}(#{params}): #{info[:return_type] || "void"}"
         md << "```"
         md << ""
 
@@ -126,7 +126,7 @@ module TRuby
           md << "| Name | Type | Description |"
           md << "|------|------|-------------|"
           info[:params].each do |param|
-            md << "| `#{param[:name]}` | `#{param[:type]}` | #{param[:description] || '-'} |"
+            md << "| `#{param[:name]}` | `#{param[:type]}` | #{param[:description] || "-"} |"
           end
           md << ""
         end
@@ -147,13 +147,13 @@ module TRuby
       files.each { |file| parse_file(file) }
 
       File.write(output_path, JSON.pretty_generate({
-        generated_at: Time.now.iso8601,
-        version: TRuby::VERSION,
-        types: @docs[:types],
-        interfaces: @docs[:interfaces],
-        functions: @docs[:functions],
-        modules: @docs[:modules]
-      }))
+                                                     generated_at: Time.now.iso8601,
+                                                     version: TRuby::VERSION,
+                                                     types: @docs[:types],
+                                                     interfaces: @docs[:interfaces],
+                                                     functions: @docs[:functions],
+                                                     modules: @docs[:modules],
+                                                   }))
 
       puts "JSON documentation generated: #{output_path}"
     end
@@ -191,7 +191,7 @@ module TRuby
           type_params: type_params&.split(/\s*,\s*/),
           definition: definition.strip,
           description: doc_comments["type:#{name}"],
-          source: relative_path
+          source: relative_path,
         }
       end
 
@@ -240,11 +240,11 @@ module TRuby
       content.scan(/interface\s+(\w+)(?:<([^>]+)>)?\s*\n((?:(?!^end).)*?)^end/m) do |name, type_params, body|
         members = []
 
-        body.scan(/^\s*(\w+[\?\!]?)\s*:\s*(.+)$/) do |member_name, member_type|
+        body.scan(/^\s*(\w+[?!]?)\s*:\s*(.+)$/) do |member_name, member_type|
           members << {
             name: member_name,
             type: member_type.strip,
-            description: doc_comments["member:#{name}.#{member_name}"]
+            description: doc_comments["member:#{name}.#{member_name}"],
           }
         end
 
@@ -253,21 +253,21 @@ module TRuby
           type_params: type_params&.split(/\s*,\s*/),
           members: members,
           description: doc_comments["interface:#{name}"],
-          source: source
+          source: source,
         }
       end
     end
 
     def parse_functions(content, source, doc_comments)
       # Match function definitions
-      content.scan(/def\s+(\w+[\?\!]?)(?:<([^>]+)>)?\s*\(([^)]*)\)(?:\s*:\s*(.+?))?(?:\n|$)/) do |name, type_params, params_str, return_type|
+      content.scan(/def\s+(\w+[?!]?)(?:<([^>]+)>)?\s*\(([^)]*)\)(?:\s*:\s*(.+?))?(?:\n|$)/) do |name, type_params, params_str, return_type|
         params = []
 
         params_str.scan(/(\w+)\s*:\s*([^,]+)/) do |param_name, param_type|
           params << {
             name: param_name,
             type: param_type.strip,
-            description: doc_comments["param:#{name}.#{param_name}"]
+            description: doc_comments["param:#{name}.#{param_name}"],
           }
         end
 
@@ -277,7 +277,7 @@ module TRuby
           params: params,
           return_type: return_type&.strip,
           description: doc_comments["def:#{name}"],
-          source: source
+          source: source,
         }
       end
     end
@@ -360,15 +360,15 @@ module TRuby
     def generate_search_index(output_dir)
       search_data = []
 
-      @docs[:types].each do |name, info|
+      @docs[:types].each_key do |name|
         search_data << { type: "type", name: name, url: "types/#{name}.html" }
       end
 
-      @docs[:interfaces].each do |name, info|
+      @docs[:interfaces].each_key do |name|
         search_data << { type: "interface", name: name, url: "interfaces/#{name}.html" }
       end
 
-      @docs[:functions].each do |name, info|
+      @docs[:functions].each_key do |name|
         search_data << { type: "function", name: name, url: "functions/#{name}.html" }
       end
 
@@ -392,8 +392,8 @@ module TRuby
         <body>
           <a href="../index.html">← Back to Index</a>
           <h1>type #{name}</h1>
-          #{info[:description] ? "<p>#{info[:description]}</p>" : ""}
-          <pre>type #{name}#{info[:type_params] ? "<#{info[:type_params].join(', ')}>" : ""} = #{info[:definition]}</pre>
+          #{"<p>#{info[:description]}</p>" if info[:description]}
+          <pre>type #{name}#{"<#{info[:type_params].join(", ")}>" if info[:type_params]} = #{info[:definition]}</pre>
           <p class="meta">Source: <code>#{info[:source]}</code></p>
         </body>
         </html>
@@ -402,7 +402,7 @@ module TRuby
 
     def generate_interface_html(name, info)
       members_html = info[:members]&.map do |m|
-        "<tr><td><code>#{m[:name]}</code></td><td><code>#{m[:type]}</code></td><td>#{m[:description] || '-'}</td></tr>"
+        "<tr><td><code>#{m[:name]}</code></td><td><code>#{m[:type]}</code></td><td>#{m[:description] || "-"}</td></tr>"
       end&.join || ""
 
       <<~HTML
@@ -423,8 +423,8 @@ module TRuby
         </head>
         <body>
           <a href="../index.html">← Back to Index</a>
-          <h1>interface #{name}#{info[:type_params] ? "&lt;#{info[:type_params].join(', ')}&gt;" : ""}</h1>
-          #{info[:description] ? "<p>#{info[:description]}</p>" : ""}
+          <h1>interface #{name}#{"&lt;#{info[:type_params].join(", ")}&gt;" if info[:type_params]}</h1>
+          #{"<p>#{info[:description]}</p>" if info[:description]}
           #{"<h2>Members</h2><table><tr><th>Name</th><th>Type</th><th>Description</th></tr>#{members_html}</table>" unless members_html.empty?}
           <p class="meta">Source: <code>#{info[:source]}</code></p>
         </body>
@@ -434,11 +434,11 @@ module TRuby
 
     def generate_function_html(name, info)
       params_html = info[:params]&.map do |p|
-        "<tr><td><code>#{p[:name]}</code></td><td><code>#{p[:type]}</code></td><td>#{p[:description] || '-'}</td></tr>"
+        "<tr><td><code>#{p[:name]}</code></td><td><code>#{p[:type]}</code></td><td>#{p[:description] || "-"}</td></tr>"
       end&.join || ""
 
       params_sig = info[:params]&.map { |p| "#{p[:name]}: #{p[:type]}" }&.join(", ") || ""
-      type_params = info[:type_params]&.any? ? "<#{info[:type_params].join(', ')}>" : ""
+      type_params = info[:type_params]&.any? ? "<#{info[:type_params].join(", ")}>" : ""
 
       <<~HTML
         <!DOCTYPE html>
@@ -459,12 +459,12 @@ module TRuby
         <body>
           <a href="../index.html">← Back to Index</a>
           <h1>#{name}</h1>
-          #{info[:description] ? "<p>#{info[:description]}</p>" : ""}
+          #{"<p>#{info[:description]}</p>" if info[:description]}
           <h2>Signature</h2>
-          <pre>def #{name}#{type_params}(#{params_sig}): #{info[:return_type] || 'void'}</pre>
+          <pre>def #{name}#{type_params}(#{params_sig}): #{info[:return_type] || "void"}</pre>
           #{"<h2>Parameters</h2><table><tr><th>Name</th><th>Type</th><th>Description</th></tr>#{params_html}</table>" unless params_html.empty?}
           <h2>Returns</h2>
-          <p><code>#{info[:return_type] || 'void'}</code></p>
+          <p><code>#{info[:return_type] || "void"}</code></p>
           <p class="meta">Source: <code>#{info[:source]}</code></p>
         </body>
         </html>

data/lib/t_ruby/docs_badge_generator.rb

@@ -148,16 +148,16 @@ module TRuby
         markdown += "Pass rate: #{file_summary[:pass_rate]}% (#{file_summary[:passed]}/#{file_summary[:total]})\n\n"
 
         failed_results = file_results.select(&:fail?)
-        if failed_results.any?
-          markdown += "**Failed examples:**\n\n"
-          failed_results.each do |result|
-            markdown += "- Line #{result.line_number}:\n"
-            result.errors.each do |error|
-              markdown += "  - #{error}\n"
-            end
+        next unless failed_results.any?
+
+        markdown += "**Failed examples:**\n\n"
+        failed_results.each do |result|
+          markdown += "- Line #{result.line_number}:\n"
+          result.errors.each do |error|
+            markdown += "  - #{error}\n"
           end
-          markdown += "\n"
         end
+        markdown += "\n"
       end
 
       File.write(output_path, markdown)

data/lib/t_ruby/docs_example_verifier.rb

@@ -173,12 +173,11 @@ module TRuby
 
     def verify_ruby_example(example)
       # For Ruby examples, just validate syntax
-      begin
-        RubyVM::InstructionSequence.compile(example.code)
-        pass_result(example)
-      rescue SyntaxError => e
-        fail_result(example, ["Ruby syntax error: #{e.message}"])
-      end
+
+      RubyVM::InstructionSequence.compile(example.code)
+      pass_result(example)
+    rescue SyntaxError => e
+      fail_result(example, ["Ruby syntax error: #{e.message}"])
     end
 
     def verify_rbs_example(example)

data/lib/t_ruby/error_handler.rb

@@ -69,7 +69,7 @@ module TRuby
         next unless line.match?(/^\s*def\s+/)
 
         # Check for unclosed parenthesis
-        if line.match?(/def\s+\w+\([^)]*$/) && !@lines[idx + 1..].any? { |l| l.match?(/\)/) }
+        if line.match?(/def\s+\w+\([^)]*$/) && @lines[(idx + 1)..].none? { |l| l.match?(/\)/) }
           @errors << "Line #{idx + 1}: Potential unclosed parenthesis in function definition"
         end
 
@@ -84,6 +84,7 @@ module TRuby
     def check_method_signature_errors
       @lines.each_with_index do |line, idx|
         next unless line.match?(/^\s*def\s+/)
+
         check_single_method_signature(line, idx)
       end
     end
@@ -96,7 +97,7 @@ module TRuby
       end
 
       # Pattern 2: Check for text after closing paren without colon (e.g., "def test() something")
-      if match = line.match(/def\s+\w+\s*\([^)]*\)\s*([^:\s].+?)\s*$/)
+      if (match = line.match(/def\s+\w+\s*\([^)]*\)\s*([^:\s].+?)\s*$/))
         trailing = match[1].strip
         # Allow if it's just end-of-line content or a valid Ruby block start
         unless trailing.empty? || trailing.start_with?("#") || trailing == "end"
@@ -112,13 +113,13 @@ module TRuby
       end
 
       # Pattern 4: Extract and validate return type
-      if match = line.match(/def\s+\w+\s*\([^)]*\)\s*:\s*(.+?)\s*$/)
+      if (match = line.match(/def\s+\w+\s*\([^)]*\)\s*:\s*(.+?)\s*$/))
         return_type_str = match[1].strip
         validate_type_expression(return_type_str, idx, "return type")
       end
 
       # Pattern 5: Extract and validate parameter types
-      if match = line.match(/def\s+\w+\s*\(([^)]+)\)/)
+      if (match = line.match(/def\s+\w+\s*\(([^)]+)\)/))
         params_str = match[1]
         validate_parameter_types_expression(params_str, idx)
       end
@@ -189,7 +190,7 @@ module TRuby
       # Use TypeParser to validate
       result = @type_parser.parse(type_str)
       if result[:success]
-        remaining = type_str[result[:position] || 0..]&.strip
+        remaining = type_str[(result[:position] || 0)..]&.strip
         if remaining && !remaining.empty? && result[:remaining] && !result[:remaining].strip.empty?
           @errors << "Line #{line_idx + 1}: Unexpected token after #{context} '#{type_str}'"
         end
@@ -207,17 +208,17 @@ module TRuby
         next if param.empty?
 
         # Check for param: Type pattern
-        if match = param.match(/^(\w+)\s*:\s*(.+)$/)
-          param_name = match[1]
-          type_str = match[2].strip
+        next unless (match = param.match(/^(\w+)\s*:\s*(.+)$/))
 
-          if type_str.empty?
-            @errors << "Line #{line_idx + 1}: Expected type after colon for parameter '#{param_name}'"
-            next
-          end
+        param_name = match[1]
+        type_str = match[2].strip
 
-          validate_type_expression(type_str, line_idx, "parameter type for '#{param_name}'")
+        if type_str.empty?
+          @errors << "Line #{line_idx + 1}: Expected type after colon for parameter '#{param_name}'"
+          next
         end
+
+        validate_type_expression(type_str, line_idx, "parameter type for '#{param_name}'")
       end
     end
 
@@ -235,7 +236,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             result << current.strip
             current = ""
           else
@@ -262,10 +263,8 @@ module TRuby
         return_type = match[2]&.strip
 
         # Check return type if it's a simple type name
-        if return_type && return_type.match?(/^\w+$/)
-          unless VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type)
-            @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
-          end
+        if return_type&.match?(/^\w+$/) && !(VALID_TYPES.include?(return_type) || @type_aliases.key?(return_type))
+          @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
         end
 
         # Check parameter types
@@ -286,10 +285,10 @@ module TRuby
         next unless param_type
 
         # Only check simple type names against VALID_TYPES
-        if param_type.match?(/^\w+$/)
-          next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
-          @errors << "Line #{line_idx + 1}: Unknown parameter type '#{param_type}'"
-        end
+        next unless param_type.match?(/^\w+$/)
+        next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
+
+        @errors << "Line #{line_idx + 1}: Unknown parameter type '#{param_type}'"
       end
     end
 

data/lib/t_ruby/generic_type_parser.rb

@@ -30,7 +30,7 @@ module TRuby
       {
         type: :generic,
         base: base_name,
-        params: params
+        params: params,
       }
     end
 
@@ -50,7 +50,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             params << current.strip
             current = ""
           else
@@ -61,7 +61,7 @@ module TRuby
         end
       end
 
-      params << current.strip if current.length > 0
+      params << current.strip if current.length.positive?
       params
     end
   end

data/lib/t_ruby/intersection_type_parser.rb

@@ -17,13 +17,13 @@ module TRuby
     private
 
     def parse_intersection
-      members = @type_string.split("&").map { |m| m.strip }.compact
+      members = @type_string.split("&").map(&:strip).compact
 
       {
         type: :intersection,
         members: members,
         has_duplicates: members.length != members.uniq.length,
-        unique_members: members.uniq
+        unique_members: members.uniq,
       }
     end
   end