t-ruby 0.0.7 → 0.0.34

data/lib/t_ruby/config.rb

@@ -3,51 +3,393 @@
 require "yaml"
 
 module TRuby
+  # Error raised when configuration is invalid
+  class ConfigError < StandardError; end
+
   class Config
+    # Valid strictness levels
+    VALID_STRICTNESS = %w[strict standard permissive].freeze
+    # New schema structure (v0.0.12+)
     DEFAULT_CONFIG = {
-      "emit" => {
-        "rb" => true,
-        "rbs" => false,
-        "dtrb" => false
+      "source" => {
+        "include" => ["src"],
+        "exclude" => [],
+        "extensions" => [".trb"]
+      },
+      "output" => {
+        "ruby_dir" => "build",
+        "rbs_dir" => nil,
+        "preserve_structure" => true,
+        "clean_before_build" => false
       },
-      "paths" => {
-        "src" => "./src",
-        "out" => "./build"
+      "compiler" => {
+        "strictness" => "standard",
+        "generate_rbs" => true,
+        "target_ruby" => "3.0",
+        "experimental" => [],
+        "checks" => {
+          "no_implicit_any" => false,
+          "no_unused_vars" => false,
+          "strict_nil" => false
+        }
       },
-      "strict" => {
-        "rbs_compat" => true,
-        "null_safety" => false,
-        "inference" => "basic"
+      "watch" => {
+        "paths" => [],
+        "debounce" => 100,
+        "clear_screen" => false,
+        "on_success" => nil
       }
     }.freeze
 
-    attr_reader :emit, :paths, :strict
+    # Legacy keys for migration detection
+    LEGACY_KEYS = %w[emit paths strict include exclude].freeze
+
+    # Always excluded (not configurable)
+    AUTO_EXCLUDE = [".git"].freeze
+
+    attr_reader :source, :output, :compiler, :watch, :version_requirement
 
     def initialize(config_path = nil)
-      config = load_config(config_path)
-      @emit = config["emit"]
-      @paths = config["paths"]
-      @strict = config["strict"]
+      raw_config = load_raw_config(config_path)
+      config = process_config(raw_config)
+
+      @source = config["source"]
+      @output = config["output"]
+      @compiler = config["compiler"]
+      @watch = config["watch"]
+      @version_requirement = raw_config["version"]
+    end
+
+    # Get output directory for compiled Ruby files
+    # @return [String] output directory path
+    def ruby_dir
+      @output["ruby_dir"] || "build"
+    end
+
+    # Get output directory for RBS files
+    # @return [String] RBS output directory (defaults to ruby_dir if not specified)
+    def rbs_dir
+      @output["rbs_dir"] || ruby_dir
+    end
+
+    # Check if source directory structure should be preserved in output
+    # @return [Boolean] true if structure should be preserved
+    def preserve_structure?
+      @output["preserve_structure"] != false
+    end
+
+    # Check if output directory should be cleaned before build
+    # @return [Boolean] true if should clean before build
+    def clean_before_build?
+      @output["clean_before_build"] == true
+    end
+
+    # Get compiler strictness level
+    # @return [String] one of: strict, standard, permissive
+    def strictness
+      @compiler["strictness"] || "standard"
+    end
+
+    # Check if RBS files should be generated
+    # @return [Boolean] true if RBS files should be generated
+    def generate_rbs?
+      @compiler["generate_rbs"] != false
+    end
+
+    # Get target Ruby version
+    # @return [String] target Ruby version (e.g., "3.0", "3.2")
+    def target_ruby
+      (@compiler["target_ruby"] || "3.0").to_s
+    end
+
+    # Get list of enabled experimental features
+    # @return [Array<String>] list of experimental feature names
+    def experimental_features
+      @compiler["experimental"] || []
+    end
+
+    # Check if a specific experimental feature is enabled
+    # @param feature [String] feature name to check
+    # @return [Boolean] true if feature is enabled
+    def experimental_enabled?(feature)
+      experimental_features.include?(feature)
+    end
+
+    # Check if no_implicit_any check is enabled
+    # @return [Boolean] true if check is enabled
+    def check_no_implicit_any?
+      @compiler.dig("checks", "no_implicit_any") == true
+    end
+
+    # Check if no_unused_vars check is enabled
+    # @return [Boolean] true if check is enabled
+    def check_no_unused_vars?
+      @compiler.dig("checks", "no_unused_vars") == true
+    end
+
+    # Check if strict_nil check is enabled
+    # @return [Boolean] true if check is enabled
+    def check_strict_nil?
+      @compiler.dig("checks", "strict_nil") == true
+    end
+
+    # Get additional watch paths
+    # @return [Array<String>] list of additional paths to watch
+    def watch_paths
+      @watch["paths"] || []
+    end
+
+    # Get watch debounce delay in milliseconds
+    # @return [Integer] debounce delay in milliseconds
+    def watch_debounce
+      @watch["debounce"] || 100
+    end
+
+    # Check if terminal should be cleared before rebuild
+    # @return [Boolean] true if terminal should be cleared
+    def watch_clear_screen?
+      @watch["clear_screen"] == true
+    end
+
+    # Get command to run after successful compilation
+    # @return [String, nil] command to run on success
+    def watch_on_success
+      @watch["on_success"]
+    end
+
+    # Check if current T-Ruby version satisfies the version requirement
+    # @return [Boolean] true if version is satisfied or no requirement specified
+    def version_satisfied?
+      return true if @version_requirement.nil?
+
+      requirement = Gem::Requirement.new(@version_requirement)
+      current = Gem::Version.new(TRuby::VERSION)
+      requirement.satisfied_by?(current)
+    rescue ArgumentError
+      false
+    end
+
+    # Validate the configuration
+    # @raise [ConfigError] if configuration is invalid
+    def validate!
+      validate_strictness!
+      true
     end
 
+    # Backwards compatible: alias for ruby_dir
     def out_dir
-      @paths["out"]
+      ruby_dir
     end
 
+    # Backwards compatible: first source.include directory
     def src_dir
-      @paths["src"]
+      @source["include"].first || "src"
+    end
+
+    # Get source include directories
+    # @return [Array<String>] list of include directories
+    def source_include
+      @source["include"] || ["src"]
+    end
+
+    # Get source exclude patterns
+    # @return [Array<String>] list of exclude patterns
+    def source_exclude
+      @source["exclude"] || []
+    end
+
+    # Get source file extensions
+    # @return [Array<String>] list of file extensions (e.g., [".trb", ".truby"])
+    def source_extensions
+      @source["extensions"] || [".trb"]
+    end
+
+    # Get include patterns for file discovery
+    def include_patterns
+      extensions = @source["extensions"] || [".trb"]
+      extensions.map { |ext| "**/*#{ext}" }
+    end
+
+    # Get exclude patterns
+    def exclude_patterns
+      @source["exclude"] || []
+    end
+
+    # Find all source files matching include patterns, excluding exclude patterns
+    # @return [Array<String>] list of matching file paths
+    def find_source_files
+      files = []
+
+      @source["include"].each do |include_dir|
+        base_dir = File.expand_path(include_dir)
+        next unless Dir.exist?(base_dir)
+
+        include_patterns.each do |pattern|
+          full_pattern = File.join(base_dir, pattern)
+          files.concat(Dir.glob(full_pattern))
+        end
+      end
+
+      # Filter out excluded files
+      files.reject { |f| excluded?(f) }.uniq.sort
+    end
+
+    # Check if a file path should be excluded
+    # @param file_path [String] absolute or relative file path
+    # @return [Boolean] true if file should be excluded
+    def excluded?(file_path)
+      relative_path = relative_to_src(file_path)
+      all_exclude_patterns.any? { |pattern| matches_pattern?(relative_path, pattern) }
     end
 
     private
 
-    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])
+    # Validate strictness value
+    def validate_strictness!
+      value = strictness
+      return if VALID_STRICTNESS.include?(value)
+
+      raise ConfigError, "Invalid compiler.strictness: '#{value}'. Must be one of: #{VALID_STRICTNESS.join(', ')}"
+    end
+
+    def load_raw_config(config_path)
+      raw = if config_path && File.exist?(config_path)
+              YAML.safe_load_file(config_path, permitted_classes: [Symbol]) || {}
+            elsif File.exist?("trbconfig.yml")
+              YAML.safe_load_file("trbconfig.yml", permitted_classes: [Symbol]) || {}
+            else
+              {}
+            end
+      expand_env_vars(raw)
+    end
+
+    # Expand environment variables in config values
+    # Supports ${VAR} and ${VAR:-default} syntax
+    def expand_env_vars(obj)
+      case obj
+      when Hash
+        obj.transform_values { |v| expand_env_vars(v) }
+      when Array
+        obj.map { |v| expand_env_vars(v) }
+      when String
+        expand_env_string(obj)
+      else
+        obj
+      end
+    end
+
+    # Expand environment variables in a single string
+    def expand_env_string(str)
+      str.gsub(/\$\{([^}]+)\}/) do |_match|
+        var_expr = ::Regexp.last_match(1)
+        if var_expr.include?(":-")
+          var_name, default_value = var_expr.split(":-", 2)
+          ENV.fetch(var_name, default_value)
+        else
+          ENV.fetch(var_expr, "")
+        end
+      end
+    end
+
+    def process_config(raw_config)
+      if legacy_config?(raw_config)
+        warn "DEPRECATED: trbconfig.yml uses legacy format. Please migrate to new schema (source/output/compiler/watch)."
+        migrate_legacy_config(raw_config)
+      else
+        merge_with_defaults(raw_config)
+      end
+    end
+
+    def legacy_config?(raw_config)
+      LEGACY_KEYS.any? { |key| raw_config.key?(key) }
+    end
+
+    def migrate_legacy_config(raw_config)
+      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")
+      end
+
+      # Migrate paths -> source.include and output.ruby_dir
+      if raw_config["paths"]
+        if raw_config["paths"]["src"]
+          src_path = raw_config["paths"]["src"].sub(%r{^\./}, "")
+          result["source"]["include"] = [src_path]
+        end
+        if raw_config["paths"]["out"]
+          out_path = raw_config["paths"]["out"].sub(%r{^\./}, "")
+          result["output"]["ruby_dir"] = out_path
+        end
+      end
+
+      # Migrate include/exclude patterns
+      if raw_config["include"]
+        # Keep legacy include patterns as-is for now
+        result["source"]["include"] = [result["source"]["include"].first || "src"]
+      end
+
+      if raw_config["exclude"]
+        result["source"]["exclude"] = raw_config["exclude"]
+      end
+
+      result
+    end
+
+    def merge_with_defaults(user_config)
+      result = deep_dup(DEFAULT_CONFIG)
+      deep_merge(result, user_config)
+      result
+    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)
+      end
+    end
+
+    def deep_merge(target, source)
+      source.each do |key, value|
+        if value.is_a?(Hash) && target[key].is_a?(Hash)
+          deep_merge(target[key], value)
+        elsif !value.nil?
+          target[key] = value
+        end
+      end
+    end
+
+    # Combine auto-excluded patterns with user-configured patterns
+    def all_exclude_patterns
+      patterns = AUTO_EXCLUDE.dup
+      patterns << out_dir.sub(%r{^\./}, "") # Add output directory
+      patterns.concat(exclude_patterns)
+      patterns.uniq
+    end
+
+    # Convert absolute path to relative path from first src_dir
+    def relative_to_src(file_path)
+      base_dir = File.expand_path(src_dir)
+      full_path = File.expand_path(file_path)
+
+      if full_path.start_with?(base_dir)
+        full_path.sub("#{base_dir}/", "")
       else
-        DEFAULT_CONFIG.dup
+        file_path
       end
     end
+
+    # Check if path matches a glob/directory pattern
+    def matches_pattern?(path, pattern)
+      # Direct directory match (e.g., "node_modules" matches "node_modules/foo.rb")
+      return true if path.start_with?("#{pattern}/") || path == pattern
+
+      # Check if any path component matches
+      path_parts = path.split("/")
+      return true if path_parts.include?(pattern)
+
+      # Glob pattern match
+      File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+    end
   end
 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