t-ruby 0.0.11 → 0.0.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f72a8bc0185eae719b855a9edb95a6fa17f9d9f3b4dfadf67f5a32b0a6ab0e32
-  data.tar.gz: 376722902f19f751b420e6e6e9c7951aebf45bc76c081c498d8ba4d92e7383f8
+  metadata.gz: 5e0ef66816ac48ae4a0e21326270f31e44bf258bd12f28bc1e2822ef2f087e89
+  data.tar.gz: 3a16ea18d0a0aabc2b5add683642c5ef346343b8b988fb0b02d9942e1f95842f
 SHA512:
-  metadata.gz: d742076e86ec5f1fdcd4bac9fe98b2fff48ed3fc964caa420f11e1d88263db26e55768e5fa6f00f1a976712d3aaf4cb6d541b3c79df863550c6f84eb2fba481b
-  data.tar.gz: ee975f1c9b0c70254f96082178734c8ae1f799565d193425a80d416bb60f088a4ccf41516b878d35a1c257ec7557c47220c65045b2d5099bfbb855446fb513f5
+  metadata.gz: b2d1d004b7d7eac3a62c7a12487b9175d53bd688f47baec72d5f23c405a79943c4f33049e60cdfbb32924f530a8e88b4895c7738978754590d4e4898e34ffae9
+  data.tar.gz: 5079f36e6bff492eca9fb6aaff1ffa56379b42dc03d09dfc413236888adb6797ac791aa1839fd9ebf3b891f319333696d0af71966076a78088f8e900ee3668f7

data/README.md

@@ -152,10 +152,21 @@ trc --version
 
 ## Quick start
 
-### 1. Write `.trb`
+### 1. Initialize project
+
+```bash
+trc --init
+```
+
+This creates:
+- `trbconfig.yml` — project configuration
+- `src/` — source directory
+- `build/` — output directory
+
+### 2. Write `.trb`
 
 ```trb
-# hello.trb
+# src/hello.trb
 def greet(name: String): String
   "Hello, #{name}!"
 end
@@ -163,19 +174,69 @@ end
 puts greet("world")
 ```
 
-### 2. Compile
+### 3. Compile
 
 ```bash
-trc hello.trb
+trc src/hello.trb
 ```
 
-### 3. Run
+### 4. Run
 
 ```bash
 ruby build/hello.rb
 # => Hello, world!
 ```
 
+### 5. Watch mode
+
+```bash
+trc -w           # Watch directories from trbconfig.yml (default: src/)
+trc -w lib/      # Watch specific directory
+```
+
+Files are automatically recompiled on change.
+
+---
+
+## Configuration
+
+`trc --init` generates a `trbconfig.yml` file with all available options:
+
+```yaml
+# T-Ruby configuration file
+# See: https://type-ruby.github.io/docs/getting-started/project-configuration
+
+source:
+  include:
+    - src
+  exclude: []
+  extensions:
+    - ".trb"
+    - ".rb"
+
+output:
+  ruby_dir: build
+  # rbs_dir: sig  # Optional: separate directory for .rbs files
+  preserve_structure: true
+  # clean_before_build: false
+
+compiler:
+  strictness: standard  # strict | standard | permissive
+  generate_rbs: true
+  target_ruby: "3.0"
+  # experimental: []
+  # checks:
+  #   no_implicit_any: false
+  #   no_unused_vars: false
+  #   strict_nil: false
+
+watch:
+  # paths: []  # Additional paths to watch
+  debounce: 100
+  # clear_screen: false
+  # on_success: "bundle exec rspec"
+```
+
 ---
 
 ## Features

data/lib/t_ruby/cli.rb

@@ -9,6 +9,7 @@ module TRuby
         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 --config, -c <path>  Use custom config file
         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)
@@ -19,6 +20,7 @@ module TRuby
         trc hello.trb            Compile hello.trb to build/hello.rb
         trc utils.rb             Copy utils.rb to build/ and generate utils.rbs
         trc --init               Create trbconfig.yml and src/, build/ directories
+        trc -c custom.yml file.trb  Compile with custom config file
         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
@@ -66,8 +68,12 @@ module TRuby
         return
       end
 
-      input_file = @args.first
-      compile(input_file)
+      # Extract config path if --config or -c flag is present
+      config_path = extract_config_path
+
+      # Get input file (first non-flag argument)
+      input_file = find_input_file
+      compile(input_file, config_path: config_path)
     end
 
     private
@@ -80,24 +86,43 @@ module TRuby
       created = []
       skipped = []
 
-      # Create trbconfig.yml
+      # Create trbconfig.yml with new schema
       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
+          # T-Ruby configuration file
+          # See: https://type-ruby.github.io/docs/getting-started/project-configuration
+
+          source:
+            include:
+              - #{src_dir}
+            exclude: []
+            extensions:
+              - ".trb"
+              - ".rb"
+
+          output:
+            ruby_dir: #{build_dir}
+            # rbs_dir: sig  # Optional: separate directory for .rbs files
+            preserve_structure: true
+            # clean_before_build: false
+
+          compiler:
+            strictness: standard  # strict | standard | permissive
+            generate_rbs: true
+            target_ruby: "3.0"
+            # experimental: []
+            # checks:
+            #   no_implicit_any: false
+            #   no_unused_vars: false
+            #   strict_nil: false
+
+          watch:
+            # paths: []  # Additional paths to watch
+            debounce: 100
+            # clear_screen: false
+            # on_success: "bundle exec rspec"
         YAML
         created << config_file
       end
@@ -161,8 +186,8 @@ module TRuby
       exit 1
     end
 
-    def compile(input_file)
-      config = Config.new
+    def compile(input_file, config_path: nil)
+      config = Config.new(config_path)
       compiler = Compiler.new(config)
 
       output_path = compiler.compile(input_file)
@@ -171,5 +196,36 @@ module TRuby
       puts "Error: #{e.message}"
       exit 1
     end
+
+    # Extract config path from --config or -c flag
+    def extract_config_path
+      config_index = @args.index("--config") || @args.index("-c")
+      return nil unless config_index
+
+      @args[config_index + 1]
+    end
+
+    # Find the input file (first non-flag argument)
+    def find_input_file
+      skip_next = false
+      @args.each do |arg|
+        if skip_next
+          skip_next = false
+          next
+        end
+
+        # Skip known flags with arguments
+        if %w[--config -c --decl].include?(arg)
+          skip_next = true
+          next
+        end
+
+        # Skip flags without arguments
+        next if arg.start_with?("-")
+
+        return arg
+      end
+      nil
+    end
   end
 end

data/lib/t_ruby/compiler.rb

@@ -47,16 +47,19 @@ module TRuby
       File.write(output_path, output)
 
       # Generate .rbs file if enabled in config
-      if @config.emit["rbs"]
+      if @config.compiler["generate_rbs"]
+        rbs_dir = @config.rbs_dir
+        FileUtils.mkdir_p(rbs_dir)
         if @use_ir && parser.ir_program
-          generate_rbs_from_ir(base_filename, out_dir, parser.ir_program)
+          generate_rbs_from_ir(base_filename, rbs_dir, parser.ir_program)
         else
-          generate_rbs_file(base_filename, out_dir, parse_result)
+          generate_rbs_file(base_filename, rbs_dir, parse_result)
         end
       end
 
-      # Generate .d.trb file if enabled in config
-      if @config.emit["dtrb"]
+      # Generate .d.trb file if enabled in config (legacy support)
+      # TODO: Add compiler.generate_dtrb option in future
+      if @config.compiler.key?("generate_dtrb") && @config.compiler["generate_dtrb"]
         generate_dtrb_file(input_path, out_dir)
       end
 
@@ -236,8 +239,10 @@ module TRuby
       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)
+      if @config.compiler["generate_rbs"]
+        rbs_dir = @config.rbs_dir
+        FileUtils.mkdir_p(rbs_dir)
+        generate_rbs_from_ruby(base_filename, rbs_dir, input_path)
       end
 
       output_path

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" => true,
-        "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?("trbconfig.yml")
-        YAML.safe_load_file("trbconfig.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/version.rb

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

data/lib/t_ruby/watcher.rb

@@ -91,7 +91,9 @@ module TRuby
     end
 
     def handle_changes(modified, added, removed)
-      changed_files = (modified + added).select { |f| f.end_with?(".trb") || f.end_with?(".rb") }
+      changed_files = (modified + added)
+        .select { |f| f.end_with?(".trb") || f.end_with?(".rb") }
+        .reject { |f| @config.excluded?(f) }
       return if changed_files.empty? && removed.empty?
 
       puts
@@ -231,26 +233,34 @@ module TRuby
     end
 
     def find_trb_files
-      files = []
-      @paths.each do |path|
-        if File.directory?(path)
-          files.concat(Dir.glob(File.join(path, "**", "*.trb")))
-        elsif File.file?(path) && path.end_with?(".trb")
-          files << path
-        end
-      end
-      files.uniq
+      find_source_files_by_extension(".trb")
     end
 
     def find_rb_files
+      find_source_files_by_extension(".rb")
+    end
+
+    def find_source_files_by_extension(ext)
       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
+
+      # If watching specific paths, use those paths
+      # Otherwise, use Config's find_source_files which respects include/exclude patterns
+      if @paths == [File.expand_path(".")]
+        # Default case: use config's src_dir with include/exclude patterns
+        files = @config.find_source_files.select { |f| f.end_with?(ext) }
+      else
+        # Specific paths provided: search in those paths but still apply exclude patterns
+        @paths.each do |path|
+          if File.directory?(path)
+            Dir.glob(File.join(path, "**", "*#{ext}")).each do |file|
+              files << file unless @config.excluded?(file)
+            end
+          elsif File.file?(path) && path.end_with?(ext) && !@config.excluded?(path)
+            files << path
+          end
         end
       end
+
       files.uniq
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.35
 platform: ruby
 authors:
 - Y. Fred Kim