t-ruby 0.0.7 → 0.0.34

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.34"
 end