t-ruby 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 054211b0b7c63b2f1b66b3cfed976385174c1b3f5904ea04357599b3c7440e8f
-  data.tar.gz: 0aa86d48811cff1bc7d7652155055f5041c0bef8e372b9dcec4a06a716534799
+  metadata.gz: f72a8bc0185eae719b855a9edb95a6fa17f9d9f3b4dfadf67f5a32b0a6ab0e32
+  data.tar.gz: 376722902f19f751b420e6e6e9c7951aebf45bc76c081c498d8ba4d92e7383f8
 SHA512:
-  metadata.gz: 73ba77dc237a8455dd60b0c098de4372cd6e9f76e00619a54669af04fd46deca80c8c6fb1c3322114442ea38a471f18f722fc66018ad14cf31469ed153c11bc8
-  data.tar.gz: 5b6c3d2d3a895f941949d79407cb2e0ce91c3d1b3a13d7e113cd02be1a8fbdd9a82fb86bf6ac1d99832d4e331861c8657b516836b334aa73c8175273835c6da5
+  metadata.gz: d742076e86ec5f1fdcd4bac9fe98b2fff48ed3fc964caa420f11e1d88263db26e55768e5fa6f00f1a976712d3aaf4cb6d541b3c79df863550c6f84eb2fba481b
+  data.tar.gz: ee975f1c9b0c70254f96082178734c8ae1f799565d193425a80d416bb60f088a4ccf41516b878d35a1c257ec7557c47220c65045b2d5099bfbb855446fb513f5

data/README.md

@@ -16,6 +16,10 @@
   <img src="https://img.shields.io/badge/coverage-90%25-brightgreen" alt="Coverage: 90%" />
 </p>
 
+<p align="center">
+  <a href="https://type-ruby.github.io"><strong>🌐 Official Website</strong></a>
+</p>
+
 <p align="center">
   <a href="#install">Install</a>
   &nbsp;&nbsp;•&nbsp;&nbsp;
@@ -106,7 +110,7 @@ end
 - Like TypeScript, types live inside your code.
 - Write `.trb`, and `trc` generates both `.rb` and `.rbs`.
 
-```ruby
+```trb
 # greet.trb
 def greet(name: String): String
   "Hello, #{name}!"
@@ -150,7 +154,7 @@ trc --version
 
 ### 1. Write `.trb`
 
-```ruby
+```trb
 # hello.trb
 def greet(name: String): String
   "Hello, #{name}!"

data/lib/t_ruby/cli.rb

@@ -7,6 +7,8 @@ module TRuby
 
       Usage:
         trc <file.trb>           Compile a .trb file to .rb
+        trc <file.rb>            Copy .rb file to build/ and generate .rbs
+        trc --init               Initialize a new t-ruby project
         trc --watch, -w          Watch input files and recompile on change
         trc --decl <file.trb>    Generate .d.trb declaration file
         trc --lsp                Start LSP server (for IDE integration)
@@ -15,8 +17,10 @@ module TRuby
 
       Examples:
         trc hello.trb            Compile hello.trb to build/hello.rb
-        trc -w                   Watch all .trb files in current directory
-        trc -w src/              Watch all .trb files in src/ directory
+        trc utils.rb             Copy utils.rb to build/ and generate utils.rbs
+        trc --init               Create trbconfig.yml and src/, build/ directories
+        trc -w                   Watch all .trb and .rb files in current directory
+        trc -w src/              Watch all .trb and .rb files in src/ directory
         trc --watch hello.trb    Watch specific file for changes
         trc --decl hello.trb     Generate hello.d.trb declaration file
         trc --lsp                Start language server for VS Code
@@ -41,6 +45,11 @@ module TRuby
         return
       end
 
+      if @args.include?("--init")
+        init_project
+        return
+      end
+
       if @args.include?("--lsp")
         start_lsp_server
         return
@@ -63,6 +72,66 @@ module TRuby
 
     private
 
+    def init_project
+      config_file = "trbconfig.yml"
+      src_dir = "src"
+      build_dir = "build"
+
+      created = []
+      skipped = []
+
+      # Create trbconfig.yml
+      if File.exist?(config_file)
+        skipped << config_file
+      else
+        File.write(config_file, <<~YAML)
+          emit:
+            rb: true
+            rbs: true
+            dtrb: false
+
+          paths:
+            src: "./#{src_dir}"
+            out: "./#{build_dir}"
+
+          strict:
+            rbs_compat: true
+            null_safety: false
+            inference: basic
+        YAML
+        created << config_file
+      end
+
+      # Create src/ directory
+      if Dir.exist?(src_dir)
+        skipped << "#{src_dir}/"
+      else
+        Dir.mkdir(src_dir)
+        created << "#{src_dir}/"
+      end
+
+      # Create build/ directory
+      if Dir.exist?(build_dir)
+        skipped << "#{build_dir}/"
+      else
+        Dir.mkdir(build_dir)
+        created << "#{build_dir}/"
+      end
+
+      # Output results
+      if created.any?
+        puts "Created: #{created.join(', ')}"
+      end
+      if skipped.any?
+        puts "Skipped (already exists): #{skipped.join(', ')}"
+      end
+      if created.empty? && skipped.any?
+        puts "Project already initialized."
+      else
+        puts "t-ruby project initialized successfully!"
+      end
+    end
+
     def start_lsp_server
       server = LSPServer.new
       server.run

data/lib/t_ruby/compiler.rb

@@ -6,13 +6,13 @@ module TRuby
   class Compiler
     attr_reader :declaration_loader, :use_ir, :optimizer
 
-    def initialize(config, use_ir: true, optimize: true)
-      @config = config
+    def initialize(config = nil, use_ir: true, optimize: true)
+      @config = config || Config.new
       @use_ir = use_ir
       @optimize = optimize
       @declaration_loader = DeclarationLoader.new
       @optimizer = IR::Optimizer.new if use_ir && optimize
-      setup_declaration_paths
+      setup_declaration_paths if @config
     end
 
     def compile(input_path)
@@ -20,8 +20,13 @@ module TRuby
         raise ArgumentError, "File not found: #{input_path}"
       end
 
+      # Handle .rb files separately
+      if input_path.end_with?(".rb")
+        return copy_ruby_file(input_path)
+      end
+
       unless input_path.end_with?(".trb")
-        raise ArgumentError, "Expected .trb file, got: #{input_path}"
+        raise ArgumentError, "Expected .trb or .rb file, got: #{input_path}"
       end
 
       source = File.read(input_path)
@@ -58,6 +63,54 @@ module TRuby
       output_path
     end
 
+    # Compile T-Ruby source code from a string (useful for WASM/playground)
+    # @param source [String] T-Ruby source code
+    # @param options [Hash] Options for compilation
+    # @option options [Boolean] :rbs Whether to generate RBS output (default: true)
+    # @return [Hash] Result with :ruby, :rbs, :errors keys
+    def compile_string(source, options = {})
+      generate_rbs = options.fetch(:rbs, true)
+
+      parser = Parser.new(source, use_combinator: @use_ir)
+      parse_result = parser.parse
+
+      # Transform source to Ruby code
+      ruby_output = @use_ir ? transform_with_ir(source, parser) : transform_legacy(source, parse_result)
+
+      # Generate RBS if requested
+      rbs_output = ""
+      if generate_rbs
+        if @use_ir && parser.ir_program
+          generator = IR::RBSGenerator.new
+          rbs_output = generator.generate(parser.ir_program)
+        else
+          generator = RBSGenerator.new
+          rbs_output = generator.generate(
+            parse_result[:functions] || [],
+            parse_result[:type_aliases] || []
+          )
+        end
+      end
+
+      {
+        ruby: ruby_output,
+        rbs: rbs_output,
+        errors: []
+      }
+    rescue ParseError => e
+      {
+        ruby: "",
+        rbs: "",
+        errors: [e.message]
+      }
+    rescue StandardError => e
+      {
+        ruby: "",
+        rbs: "",
+        errors: ["Compilation error: #{e.message}"]
+      }
+    end
+
     # Compile to IR without generating output files
     def compile_to_ir(input_path)
       unless File.exist?(input_path)
@@ -166,6 +219,36 @@ module TRuby
       generator = DeclarationGenerator.new
       generator.generate_file(input_path, out_dir)
     end
+
+    # Copy .rb file to output directory and generate .rbs signature
+    def copy_ruby_file(input_path)
+      unless File.exist?(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")
+
+      # Copy the .rb file to output directory
+      FileUtils.cp(input_path, output_path)
+
+      # Generate .rbs file if enabled in config
+      if @config.emit["rbs"]
+        generate_rbs_from_ruby(base_filename, out_dir, 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")
+      result = `rbs prototype rb #{input_path} 2>/dev/null`
+      File.write(rbs_path, result) unless result.strip.empty?
+    end
   end
 
   # IR-aware code generator for source-preserving transformation

data/lib/t_ruby/config.rb

@@ -7,7 +7,7 @@ module TRuby
     DEFAULT_CONFIG = {
       "emit" => {
         "rb" => true,
-        "rbs" => false,
+        "rbs" => true,
         "dtrb" => false
       },
       "paths" => {
@@ -43,8 +43,8 @@ module TRuby
     def load_config(config_path)
       if config_path && File.exist?(config_path)
         YAML.safe_load_file(config_path, permitted_classes: [Symbol])
-      elsif File.exist?(".trb.yml")
-        YAML.safe_load_file(".trb.yml", permitted_classes: [Symbol])
+      elsif File.exist?("trbconfig.yml")
+        YAML.safe_load_file("trbconfig.yml", permitted_classes: [Symbol])
       else
         DEFAULT_CONFIG.dup
       end

data/lib/t_ruby/docs_badge_generator.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative "docs_example_verifier"
+
+module TRuby
+  # Generates badges and reports for documentation verification results.
+  #
+  # Supports:
+  # - Shields.io compatible JSON badges
+  # - SVG badge generation
+  # - Markdown report generation
+  # - JSON report generation
+  #
+  # @example
+  #   generator = DocsBadgeGenerator.new
+  #   verifier = DocsExampleVerifier.new
+  #   results = verifier.verify_glob("docs/**/*.md")
+  #   generator.generate_badge(results, "coverage/docs_badge.json")
+  #
+  class DocsBadgeGenerator
+    # Badge colors based on pass rate
+    COLORS = {
+      excellent: "brightgreen",   # 95-100%
+      good: "green",              # 80-94%
+      fair: "yellow",             # 60-79%
+      poor: "orange",             # 40-59%
+      critical: "red",            # 0-39%
+    }.freeze
+
+    def initialize
+      @verifier = DocsExampleVerifier.new
+    end
+
+    # Generate all outputs
+    #
+    # @param results [Array<DocsExampleVerifier::VerificationResult>] Results
+    # @param output_dir [String] Output directory
+    def generate_all(results, output_dir)
+      FileUtils.mkdir_p(output_dir)
+
+      generate_badge_json(results, File.join(output_dir, "docs_badge.json"))
+      generate_badge_svg(results, File.join(output_dir, "docs_badge.svg"))
+      generate_report_json(results, File.join(output_dir, "docs_report.json"))
+      generate_report_markdown(results, File.join(output_dir, "docs_report.md"))
+    end
+
+    # Generate Shields.io compatible JSON badge
+    #
+    # @param results [Array<DocsExampleVerifier::VerificationResult>] Results
+    # @param output_path [String] Output file path
+    def generate_badge_json(results, output_path)
+      summary = @verifier.summary(results)
+      pass_rate = summary[:pass_rate]
+
+      badge = {
+        schemaVersion: 1,
+        label: "docs examples",
+        message: "#{pass_rate}%",
+        color: color_for_rate(pass_rate),
+      }
+
+      File.write(output_path, JSON.pretty_generate(badge))
+    end
+
+    # Generate SVG badge
+    #
+    # @param results [Array<DocsExampleVerifier::VerificationResult>] Results
+    # @param output_path [String] Output file path
+    def generate_badge_svg(results, output_path)
+      summary = @verifier.summary(results)
+      pass_rate = summary[:pass_rate]
+      color = svg_color_for_rate(pass_rate)
+
+      svg = <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" width="140" height="20">
+          <linearGradient id="b" x2="0" y2="100%">
+            <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+            <stop offset="1" stop-opacity=".1"/>
+          </linearGradient>
+          <mask id="a">
+            <rect width="140" height="20" rx="3" fill="#fff"/>
+          </mask>
+          <g mask="url(#a)">
+            <path fill="#555" d="M0 0h85v20H0z"/>
+            <path fill="#{color}" d="M85 0h55v20H85z"/>
+            <path fill="url(#b)" d="M0 0h140v20H0z"/>
+          </g>
+          <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+            <text x="42.5" y="15" fill="#010101" fill-opacity=".3">docs examples</text>
+            <text x="42.5" y="14">docs examples</text>
+            <text x="112" y="15" fill="#010101" fill-opacity=".3">#{pass_rate}%</text>
+            <text x="112" y="14">#{pass_rate}%</text>
+          </g>
+        </svg>
+      SVG
+
+      File.write(output_path, svg)
+    end
+
+    # Generate JSON report
+    #
+    # @param results [Array<DocsExampleVerifier::VerificationResult>] Results
+    # @param output_path [String] Output file path
+    def generate_report_json(results, output_path)
+      summary = @verifier.summary(results)
+
+      report = {
+        generated_at: Time.now.iso8601,
+        summary: summary,
+        files: group_results_by_file(results),
+      }
+
+      File.write(output_path, JSON.pretty_generate(report))
+    end
+
+    # Generate Markdown report
+    #
+    # @param results [Array<DocsExampleVerifier::VerificationResult>] Results
+    # @param output_path [String] Output file path
+    def generate_report_markdown(results, output_path)
+      summary = @verifier.summary(results)
+      grouped = group_results_by_file(results)
+
+      markdown = <<~MD
+        # Documentation Examples Verification Report
+
+        Generated: #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}
+
+        ## Summary
+
+        | Metric | Value |
+        |--------|-------|
+        | Total Examples | #{summary[:total]} |
+        | Passed | #{summary[:passed]} |
+        | Failed | #{summary[:failed]} |
+        | Skipped | #{summary[:skipped]} |
+        | **Pass Rate** | **#{summary[:pass_rate]}%** |
+
+        ## Results by File
+
+      MD
+
+      grouped.each do |file_path, file_results|
+        file_summary = @verifier.summary(file_results)
+        status_emoji = file_summary[:failed].zero? ? "✅" : "❌"
+
+        markdown += "### #{status_emoji} #{file_path}\n\n"
+        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
+          end
+          markdown += "\n"
+        end
+      end
+
+      File.write(output_path, markdown)
+    end
+
+    private
+
+    def color_for_rate(rate)
+      case rate
+      when 95..100 then COLORS[:excellent]
+      when 80...95 then COLORS[:good]
+      when 60...80 then COLORS[:fair]
+      when 40...60 then COLORS[:poor]
+      else COLORS[:critical]
+      end
+    end
+
+    def svg_color_for_rate(rate)
+      case rate
+      when 95..100 then "#4c1"      # bright green
+      when 80...95 then "#97ca00"   # green
+      when 60...80 then "#dfb317"   # yellow
+      when 40...60 then "#fe7d37"   # orange
+      else "#e05d44"                # red
+      end
+    end
+
+    def group_results_by_file(results)
+      results.group_by(&:file_path)
+    end
+  end
+end

data/lib/t_ruby/docs_example_extractor.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module TRuby
+  # Extracts code examples from Markdown documentation files.
+  #
+  # Supports extracting:
+  # - T-Ruby code blocks (```trb, ```t-ruby, ```ruby with type annotations)
+  # - Ruby code blocks for comparison
+  # - RBS type definitions
+  #
+  # @example
+  #   extractor = DocsExampleExtractor.new
+  #   examples = extractor.extract_from_file("docs/getting-started.md")
+  #   examples.each { |ex| puts ex.code }
+  #
+  class DocsExampleExtractor
+    # Represents an extracted code example
+    CodeExample = Struct.new(
+      :code,           # The code content
+      :language,       # Language identifier (trb, ruby, rbs)
+      :file_path,      # Source file path
+      :line_number,    # Starting line number
+      :metadata,       # Optional metadata from code fence
+      keyword_init: true
+    ) do
+      def trb?
+        %w[trb t-ruby].include?(language)
+      end
+
+      def ruby?
+        language == "ruby"
+      end
+
+      def rbs?
+        language == "rbs"
+      end
+
+      def should_verify?
+        !metadata&.include?("skip-verify")
+      end
+
+      def should_compile?
+        !metadata&.include?("no-compile")
+      end
+
+      def should_typecheck?
+        !metadata&.include?("no-typecheck")
+      end
+    end
+
+    # Code fence pattern: ```language title="file.ext" {metadata}
+    # Supports Docusaurus format: ```ruby title="example.trb"
+    CODE_FENCE_PATTERN = /^```(\w+)?(?:\s+title="([^"]*)")?(?:\s*\{([^}]*)\})?/
+
+    # Extract all code examples from a file
+    #
+    # @param file_path [String] Path to the markdown file
+    # @return [Array<CodeExample>] Extracted code examples
+    def extract_from_file(file_path)
+      content = File.read(file_path, encoding: "UTF-8")
+      extract_from_content(content, file_path)
+    end
+
+    # Extract all code examples from content
+    #
+    # @param content [String] Markdown content
+    # @param file_path [String] Source file path (for reference)
+    # @return [Array<CodeExample>] Extracted code examples
+    def extract_from_content(content, file_path = "<string>")
+      examples = []
+      lines = content.lines
+      in_code_block = false
+      current_block = nil
+      block_start_line = 0
+
+      lines.each_with_index do |line, index|
+        line_number = index + 1
+
+        if !in_code_block && (match = line.match(CODE_FENCE_PATTERN))
+          in_code_block = true
+          block_start_line = line_number
+          lang = match[1] || "text"
+          title = match[2]
+          metadata = match[3]
+
+          # If title ends with .trb, treat as T-Ruby regardless of language tag
+          if title&.end_with?(".trb")
+            lang = "trb"
+          end
+
+          current_block = {
+            language: lang,
+            metadata: metadata,
+            title: title,
+            lines: [],
+          }
+        elsif in_code_block && line.match(/^```\s*$/)
+          in_code_block = false
+
+          # Only include relevant languages
+          if relevant_language?(current_block[:language])
+            examples << CodeExample.new(
+              code: current_block[:lines].join,
+              language: normalize_language(current_block[:language]),
+              file_path: file_path,
+              line_number: block_start_line,
+              metadata: current_block[:metadata]
+            )
+          end
+
+          current_block = nil
+        elsif in_code_block
+          current_block[:lines] << line
+        end
+      end
+
+      examples
+    end
+
+    # Extract from multiple files using glob pattern
+    #
+    # @param pattern [String] Glob pattern (e.g., "docs/**/*.md")
+    # @return [Array<CodeExample>] All extracted examples
+    def extract_from_glob(pattern)
+      Dir.glob(pattern).flat_map { |file| extract_from_file(file) }
+    end
+
+    # Get statistics about extracted examples
+    #
+    # @param examples [Array<CodeExample>] Code examples
+    # @return [Hash] Statistics
+    def statistics(examples)
+      {
+        total: examples.size,
+        trb: examples.count(&:trb?),
+        ruby: examples.count(&:ruby?),
+        rbs: examples.count(&:rbs?),
+        verifiable: examples.count(&:should_verify?),
+        files: examples.map(&:file_path).uniq.size,
+      }
+    end
+
+    private
+
+    def relevant_language?(lang)
+      %w[trb t-ruby ruby rbs].include?(lang&.downcase)
+    end
+
+    def normalize_language(lang)
+      case lang&.downcase
+      when "t-ruby" then "trb"
+      else lang&.downcase || "text"
+      end
+    end
+  end
+end

data/lib/t_ruby/docs_example_verifier.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require_relative "docs_example_extractor"
+
+module TRuby
+  # Verifies code examples extracted from documentation.
+  #
+  # Performs:
+  # - Syntax validation (parsing)
+  # - Type checking (for .trb examples)
+  # - Compilation (generates Ruby output)
+  #
+  # @example
+  #   verifier = DocsExampleVerifier.new
+  #   results = verifier.verify_file("docs/getting-started.md")
+  #   results.each { |r| puts "#{r.status}: #{r.file_path}:#{r.line_number}" }
+  #
+  class DocsExampleVerifier
+    # Result of verifying a single example
+    VerificationResult = Struct.new(
+      :example,        # The original CodeExample
+      :status,         # :pass, :fail, :skip
+      :errors,         # Array of error messages
+      :output,         # Compiled output (if applicable)
+      keyword_init: true
+    ) do
+      def pass?
+        status == :pass
+      end
+
+      def fail?
+        status == :fail
+      end
+
+      def skip?
+        status == :skip
+      end
+
+      def file_path
+        example.file_path
+      end
+
+      def line_number
+        example.line_number
+      end
+    end
+
+    def initialize
+      @extractor = DocsExampleExtractor.new
+      @compiler = TRuby::Compiler.new
+    end
+
+    # Verify all examples in a file
+    #
+    # @param file_path [String] Path to the markdown file
+    # @return [Array<VerificationResult>] Results for each example
+    def verify_file(file_path)
+      examples = @extractor.extract_from_file(file_path)
+      examples.map { |example| verify_example(example) }
+    end
+
+    # Verify all examples from multiple files
+    #
+    # @param pattern [String] Glob pattern
+    # @return [Array<VerificationResult>] All results
+    def verify_glob(pattern)
+      examples = @extractor.extract_from_glob(pattern)
+      examples.map { |example| verify_example(example) }
+    end
+
+    # Verify a single code example
+    #
+    # @param example [DocsExampleExtractor::CodeExample] The example to verify
+    # @return [VerificationResult] The verification result
+    def verify_example(example)
+      return skip_result(example, "Marked as skip-verify") unless example.should_verify?
+
+      case example.language
+      when "trb"
+        verify_trb_example(example)
+      when "ruby"
+        verify_ruby_example(example)
+      when "rbs"
+        verify_rbs_example(example)
+      else
+        skip_result(example, "Unknown language: #{example.language}")
+      end
+    rescue StandardError => e
+      fail_result(example, ["Exception: #{e.message}"])
+    end
+
+    # Generate a summary report
+    #
+    # @param results [Array<VerificationResult>] Verification results
+    # @return [Hash] Summary statistics
+    def summary(results)
+      {
+        total: results.size,
+        passed: results.count(&:pass?),
+        failed: results.count(&:fail?),
+        skipped: results.count(&:skip?),
+        pass_rate: results.empty? ? 0 : (results.count(&:pass?).to_f / results.size * 100).round(2),
+      }
+    end
+
+    # Print results to stdout
+    #
+    # @param results [Array<VerificationResult>] Verification results
+    # @param verbose [Boolean] Show passing tests too
+    def print_results(results, verbose: false)
+      results.each do |result|
+        next if result.pass? && !verbose
+
+        status_icon = case result.status
+                      when :pass then "\e[32m✓\e[0m"
+                      when :fail then "\e[31m✗\e[0m"
+                      when :skip then "\e[33m○\e[0m"
+                      end
+
+        puts "#{status_icon} #{result.file_path}:#{result.line_number}"
+
+        result.errors&.each do |error|
+          puts "    #{error}"
+        end
+      end
+
+      summary_data = summary(results)
+      puts
+      puts "Results: #{summary_data[:passed]} passed, #{summary_data[:failed]} failed, #{summary_data[:skipped]} skipped"
+      puts "Pass rate: #{summary_data[:pass_rate]}%"
+    end
+
+    private
+
+    def verify_trb_example(example)
+      errors = []
+
+      # Step 1: Parse
+      ir_program = nil
+      begin
+        parser = TRuby::Parser.new(example.code)
+        parser.parse
+        ir_program = parser.ir_program
+      rescue TRuby::ParseError => e
+        return fail_result(example, ["Parse error: #{e.message}"])
+      end
+
+      # Step 2: Type check (if enabled)
+      if example.should_typecheck? && ir_program
+        begin
+          type_checker = TRuby::TypeChecker.new(use_smt: false)
+          result = type_checker.check_program(ir_program)
+          if result[:errors]&.any?
+            errors.concat(result[:errors].map { |e| "Type error: #{e}" })
+          end
+        rescue StandardError => e
+          errors << "Type check error: #{e.message}"
+        end
+      end
+
+      # Step 3: Compile (if enabled)
+      output = nil
+      if example.should_compile?
+        begin
+          output = @compiler.compile_string(example.code)
+        rescue StandardError => e
+          errors << "Compile error: #{e.message}"
+        end
+      end
+
+      errors.empty? ? pass_result(example, output) : fail_result(example, errors)
+    end
+
+    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
+    end
+
+    def verify_rbs_example(example)
+      # For RBS, we just do basic validation
+      # Full RBS validation would require rbs gem
+      if example.code.include?("def ") || example.code.include?("type ") ||
+         example.code.include?("interface ") || example.code.include?("class ")
+        pass_result(example)
+      else
+        skip_result(example, "Cannot validate RBS without rbs gem")
+      end
+    end
+
+    def pass_result(example, output = nil)
+      VerificationResult.new(
+        example: example,
+        status: :pass,
+        errors: [],
+        output: output
+      )
+    end
+
+    def fail_result(example, errors)
+      VerificationResult.new(
+        example: example,
+        status: :fail,
+        errors: errors,
+        output: nil
+      )
+    end
+
+    def skip_result(example, reason)
+      VerificationResult.new(
+        example: example,
+        status: :skip,
+        errors: [reason],
+        output: nil
+      )
+    end
+  end
+end

data/lib/t_ruby/error_handler.rb

@@ -9,6 +9,7 @@ module TRuby
       @lines = source.split("\n")
       @errors = []
       @functions = {}
+      @type_parser = ParserCombinator::TypeParser.new
     end
 
     def check
@@ -20,6 +21,7 @@ module TRuby
       check_type_alias_errors
       check_interface_errors
       check_syntax_errors
+      check_method_signature_errors
       check_type_validation
       check_duplicate_definitions
 
@@ -78,20 +80,192 @@ module TRuby
       end
     end
 
+    # New comprehensive method signature validation
+    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
+
+    def check_single_method_signature(line, idx)
+      # Pattern 1: Check for colon without type (e.g., "def test():")
+      if line.match?(/def\s+\w+[^:]*\)\s*:\s*$/)
+        @errors << "Line #{idx + 1}: Expected type after colon, but found end of line"
+        return
+      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*$/)
+        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"
+          @errors << "Line #{idx + 1}: Unexpected token '#{trailing}' after method parameters - did you forget ':'?"
+        end
+        return
+      end
+
+      # Pattern 3: Check for parameter with colon but no type (e.g., "def test(x:)")
+      if line.match?(/def\s+\w+\s*\([^)]*\w+:\s*[,)]/)
+        @errors << "Line #{idx + 1}: Expected type after parameter colon"
+        return
+      end
+
+      # Pattern 4: Extract and validate return type
+      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*\(([^)]+)\)/)
+        params_str = match[1]
+        validate_parameter_types_expression(params_str, idx)
+      end
+    end
+
+    def validate_type_expression(type_str, line_idx, context = "type")
+      return if type_str.nil? || type_str.empty?
+
+      # Check for whitespace in simple type names (e.g., "Str ing")
+      if type_str.match?(/^[A-Z][a-z]*\s+[a-z]+/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - unexpected whitespace in type name"
+        return
+      end
+
+      # Check for trailing operators (e.g., "String |" or "String &")
+      if type_str.match?(/[|&]\s*$/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - trailing operator"
+        return
+      end
+
+      # Check for leading operators
+      if type_str.match?(/^\s*[|&]/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - leading operator"
+        return
+      end
+
+      # Check for double operators (e.g., "String | | Integer")
+      if type_str.match?(/[|&]\s*[|&]/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - consecutive operators"
+        return
+      end
+
+      # Check for unclosed brackets
+      if type_str.count("<") != type_str.count(">")
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - unbalanced angle brackets"
+        return
+      end
+
+      if type_str.count("[") != type_str.count("]")
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - unbalanced square brackets"
+        return
+      end
+
+      if type_str.count("(") != type_str.count(")")
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - unbalanced parentheses"
+        return
+      end
+
+      # Check for empty generic arguments (e.g., "Array<>")
+      if type_str.match?(/<\s*>/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - empty generic arguments"
+        return
+      end
+
+      # Check for generic without base type (e.g., "<String>")
+      if type_str.match?(/^\s*</)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - missing base type for generic"
+        return
+      end
+
+      # Check for missing arrow target in function type
+      if type_str.match?(/->\s*$/)
+        @errors << "Line #{line_idx + 1}: Invalid #{context} '#{type_str}' - missing return type after ->"
+        return
+      end
+
+      # Check for extra tokens after valid type (e.g., "String something_else")
+      # Use TypeParser to validate
+      result = @type_parser.parse(type_str)
+      if result[:success]
+        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
+      end
+    end
+
+    def validate_parameter_types_expression(params_str, line_idx)
+      return if params_str.nil? || params_str.empty?
+
+      # Split parameters handling nested generics
+      params = split_parameters(params_str)
+
+      params.each do |param|
+        param = param.strip
+        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
+
+          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
+    end
+
+    def split_parameters(params_str)
+      result = []
+      current = ""
+      depth = 0
+
+      params_str.each_char do |char|
+        case char
+        when "<", "[", "("
+          depth += 1
+          current += char
+        when ">", "]", ")"
+          depth -= 1
+          current += char
+        when ","
+          if depth == 0
+            result << current.strip
+            current = ""
+          else
+            current += char
+          end
+        else
+          current += char
+        end
+      end
+
+      result << current.strip unless current.empty?
+      result
+    end
+
     def check_type_validation
       @lines.each_with_index do |line, idx|
         next unless line.match?(/^\s*def\s+/)
 
-        # Extract types from function definition
-        match = line.match(/def\s+\w+\s*\((.*?)\)\s*(?::\s*(\w+))?/)
+        # Extract types from function definition - now handle complex types
+        match = line.match(/def\s+\w+\s*\((.*?)\)\s*(?::\s*(.+?))?$/)
         next unless match
 
         params_str = match[1]
-        return_type = match[2]
+        return_type = match[2]&.strip
 
-        # Check return type
-        if return_type && !VALID_TYPES.include?(return_type) && !@type_aliases.key?(return_type)
-          @errors << "Line #{idx + 1}: Unknown return type '#{return_type}'"
+        # 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
         end
 
         # Check parameter types
@@ -100,18 +274,22 @@ module TRuby
     end
 
     def check_parameter_types(params_str, line_idx)
-      return if params_str.empty?
+      return if params_str.nil? || params_str.empty?
 
-      param_list = params_str.split(",").map(&:strip)
-      param_list.each do |param|
-        match = param.match(/^(\w+)(?::\s*(\w+))?$/)
+      params = split_parameters(params_str)
+      params.each do |param|
+        param = param.strip
+        match = param.match(/^(\w+)(?::\s*(.+))?$/)
         next unless match
 
-        param_type = match[2]
+        param_type = match[2]&.strip
         next unless param_type
-        next if VALID_TYPES.include?(param_type) || @type_aliases.key?(param_type)
 
-        @errors << "Line #{line_idx + 1}: Unknown parameter type '#{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
       end
     end
 

data/lib/t_ruby/parser.rb

@@ -116,6 +116,11 @@ module TRuby
       params_str = match[2]
       return_type_str = match[3]&.strip
 
+      # Validate return type if present
+      if return_type_str
+        return_type_str = validate_and_extract_type(return_type_str)
+      end
+
       params = parse_parameters(params_str)
 
       result = {
@@ -133,6 +138,34 @@ module TRuby
       result
     end
 
+    # Validate type string and return nil if invalid
+    def validate_and_extract_type(type_str)
+      return nil if type_str.nil? || type_str.empty?
+
+      # Check for whitespace in simple type names that would be invalid
+      # Pattern: Capital letter followed by lowercase, then space, then more lowercase
+      # e.g., "Str ing", "Int eger", "Bool ean"
+      if type_str.match?(/^[A-Z][a-z]*\s+[a-z]+/)
+        return nil
+      end
+
+      # Check for trailing operators
+      return nil if type_str.match?(/[|&]\s*$/)
+
+      # Check for leading operators
+      return nil if type_str.match?(/^\s*[|&]/)
+
+      # Check for unbalanced brackets
+      return nil if type_str.count("<") != type_str.count(">")
+      return nil if type_str.count("[") != type_str.count("]")
+      return nil if type_str.count("(") != type_str.count(")")
+
+      # Check for empty generic arguments
+      return nil if type_str.match?(/<\s*>/)
+
+      type_str
+    end
+
     def parse_parameters(params_str)
       return [] if params_str.empty?
 

data/lib/t_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TRuby
-  VERSION = "0.0.7"
+  VERSION = "0.0.11"
 end

data/lib/t_ruby/watcher.rb

@@ -59,8 +59,8 @@ module TRuby
       compile_all
       @stats[:total_time] += Time.now - start_time
 
-      # Start watching
-      listener = Listen.to(*watch_directories, only: /\.trb$/) do |modified, added, removed|
+      # Start watching (.trb and .rb files)
+      listener = Listen.to(*watch_directories, only: /\.(trb|rb)$/) do |modified, added, removed|
         handle_changes(modified, added, removed)
       end
 
@@ -91,7 +91,7 @@ module TRuby
     end
 
     def handle_changes(modified, added, removed)
-      changed_files = (modified + added).select { |f| f.end_with?(".trb") }
+      changed_files = (modified + added).select { |f| f.end_with?(".trb") || f.end_with?(".rb") }
       return if changed_files.empty? && removed.empty?
 
       puts
@@ -120,7 +120,9 @@ module TRuby
       errors = []
 
       trb_files = find_trb_files
-      @file_count = trb_files.size
+      rb_files = find_rb_files
+      all_files = trb_files + rb_files
+      @file_count = all_files.size
 
       if @incremental && @cross_file_check
         # Use enhanced incremental compiler with cross-file checking
@@ -128,9 +130,15 @@ module TRuby
         errors = result[:errors].map { |e| format_error(e[:file], e[:error] || e[:message]) }
         @error_count = errors.size
         @stats[:total_compilations] += trb_files.size
-      elsif @parallel && trb_files.size > 1
+
+        # Also compile .rb files
+        rb_files.each do |file|
+          result = compile_file(file)
+          errors.concat(result[:errors]) if result[:errors].any?
+        end
+      elsif @parallel && all_files.size > 1
         # Parallel compilation
-        results = @parallel_processor.process_files(trb_files) do |file|
+        results = @parallel_processor.process_files(all_files) do |file|
           compile_file(file)
         end
         results.each do |result|
@@ -138,7 +146,7 @@ module TRuby
         end
       else
         # Sequential compilation
-        trb_files.each do |file|
+        all_files.each do |file|
           result = compile_file(file)
           errors.concat(result[:errors]) if result[:errors].any?
         end
@@ -234,6 +242,18 @@ module TRuby
       files.uniq
     end
 
+    def find_rb_files
+      files = []
+      @paths.each do |path|
+        if File.directory?(path)
+          files.concat(Dir.glob(File.join(path, "**", "*.rb")))
+        elsif File.file?(path) && path.end_with?(".rb")
+          files << path
+        end
+      end
+      files.uniq
+    end
+
     def format_error(file, message)
       # Parse error message for line/column info if available
       # Format: file:line:col - error TRB0001: message

data/lib/t_ruby.rb

@@ -38,5 +38,10 @@ require_relative "t_ruby/bundler_integration"
 require_relative "t_ruby/benchmark"
 require_relative "t_ruby/doc_generator"
 
+# Milestone -7: Documentation Verification
+require_relative "t_ruby/docs_example_extractor"
+require_relative "t_ruby/docs_example_verifier"
+require_relative "t_ruby/docs_badge_generator"
+
 module TRuby
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Y. Fred Kim
@@ -45,6 +45,9 @@ files:
 - lib/t_ruby/constraint_checker.rb
 - lib/t_ruby/declaration_generator.rb
 - lib/t_ruby/doc_generator.rb
+- lib/t_ruby/docs_badge_generator.rb
+- lib/t_ruby/docs_example_extractor.rb
+- lib/t_ruby/docs_example_verifier.rb
 - lib/t_ruby/error_handler.rb
 - lib/t_ruby/generic_type_parser.rb
 - lib/t_ruby/intersection_type_parser.rb