t-ruby 0.0.34 → 0.0.36

data/lib/t_ruby/compiler.rb

@@ -42,7 +42,7 @@ module TRuby
       FileUtils.mkdir_p(out_dir)
 
       base_filename = File.basename(input_path, ".trb")
-      output_path = File.join(out_dir, base_filename + ".rb")
+      output_path = File.join(out_dir, "#{base_filename}.rb")
 
       File.write(output_path, output)
 
@@ -98,19 +98,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
 
@@ -202,7 +202,7 @@ module TRuby
       generator = IR::RBSGenerator.new
       rbs_content = generator.generate(ir_program)
 
-      rbs_path = File.join(out_dir, base_filename + ".rbs")
+      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
       File.write(rbs_path, rbs_content) unless rbs_content.strip.empty?
     end
 
@@ -214,7 +214,7 @@ module TRuby
         parse_result[:type_aliases] || []
       )
 
-      rbs_path = File.join(out_dir, base_filename + ".rbs")
+      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
       File.write(rbs_path, rbs_content) unless rbs_content.empty?
     end
 
@@ -233,7 +233,7 @@ module TRuby
       FileUtils.mkdir_p(out_dir)
 
       base_filename = File.basename(input_path, ".rb")
-      output_path = File.join(out_dir, base_filename + ".rb")
+      output_path = File.join(out_dir, "#{base_filename}.rb")
 
       # Copy the .rb file to output directory
       FileUtils.cp(input_path, output_path)
@@ -250,7 +250,7 @@ module TRuby
 
     # 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")
+      rbs_path = File.join(out_dir, "#{base_filename}.rbs")
       result = `rbs prototype rb #{input_path} 2>/dev/null`
       File.write(rbs_path, result) unless result.strip.empty?
     end
@@ -273,20 +273,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 +296,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 +306,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 +338,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             params << clean_param(current.strip)
             current = ""
           else
@@ -358,7 +356,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 +368,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,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)