t-ruby 0.0.43 → 0.0.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb406ad473738afc16343a01b9f7e8e0f77a8b0fe700dd3ced2df65197bce626
-  data.tar.gz: 95f1ce4ede5378e17393046c223c46b404d95e6506235e210aeba20a9615f8ac
+  metadata.gz: 509e1090df12fc29ea3109541a6e59133bf7516b31e4859bda8a6830d44f6999
+  data.tar.gz: 8dd1ef0eb0eeea4faccfd13372235d509997b65b9e556299542e880e6bb6ab85
 SHA512:
-  metadata.gz: 6003aa038a7b476b8682aed9e32ba19ddbee6c124fe294c79b0371924527002f20c3ccdf45f71e2ee7360bef4e126d1ee0c15d93afd033df1166c20b5719187a
-  data.tar.gz: c0c462fada5b5d98f46298dc307d6000b56d537b8d7f80af1faba2206c682cebf02e588277ca5ea2bf6f4e21141928540c733f0f8851adc48b4ca1be8ede6f81
+  metadata.gz: d97698f9bf39ac32ef8635e5f6a0e8ca1819490c5907bc3997563b6082c88d13bd5ad29e3c6a88aba808fcaf1802a15a43b0a4a0faea67b02f9cd6d2dec526c0
+  data.tar.gz: 5de7ceb419cf6667ff43c1662676d3222ef6c589fb9b9831c8e7e695dd7b4e5b07e3e70039818018ff8997328423b96e63f40a588a005985eda35b836ff52892

data/README.md

@@ -243,7 +243,7 @@ watch:
 
 - **Type annotations** — Parameter and return types, erased at compile time
 - **Union types** — `String | Integer | nil`
-- **Generics** — `Array<User>`, `Hash<String, Integer>`
+- **Generics** — `User[]`, `Array<User>`, `Hash<String, Integer>`
 - **Interfaces** — Define contracts between objects
 - **Type aliases** — `type UserID = Integer`
 - **RBS generation** — Works with Steep, Ruby LSP, Sorbet
@@ -284,6 +284,16 @@ See [ROADMAP.md](./ROADMAP.md) for details.
 
 Contributions are welcome! Please feel free to submit issues and pull requests.
 
+## ❤️ Support T-Ruby
+
+If you find T-Ruby useful, consider sponsoring the project to support ongoing development and experimentation.
+
+<p align="center">
+  <a href="https://github.com/sponsors/type-ruby">
+    <img src="https://img.shields.io/badge/Sponsor-❤️-ea4aaa" alt="Sponsor" />
+  </a>
+</p>
+
 ## License
 
-[MIT](./LICENSE)
+[BSD 2-Clause](./LICENSE)

data/bin/t-ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/t_ruby"
+
+TRuby::RunnerCLI.start(ARGV)

data/lib/t_ruby/benchmark.rb

@@ -3,6 +3,7 @@
 require "benchmark"
 require "json"
 require "fileutils"
+require "time"
 
 module TRuby
   # Benchmark suite for T-Ruby performance measurement

data/lib/t_ruby/bundler_integration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "time"
 
 module TRuby
   # Integrates T-Ruby type packages with Bundler/RubyGems ecosystem

data/lib/t_ruby/cli.rb

@@ -13,6 +13,7 @@ module TRuby
         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)
+        trc run <file.trb>       Run a .trb file directly (delegates to t-ruby)
         trc update               Update t-ruby to the latest version
         trc --version, -v        Show version (and check for updates)
         trc --help, -h           Show this help
@@ -27,6 +28,7 @@ module TRuby
         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
+        trc run hello.trb        Run hello.trb directly without compilation
     HELP
 
     def self.run(args)
@@ -64,6 +66,11 @@ module TRuby
         return
       end
 
+      if @args.first == "run"
+        run_direct
+        return
+      end
+
       if @args.include?("--watch") || @args.include?("-w")
         start_watch_mode
         return
@@ -186,6 +193,16 @@ module TRuby
       server.run
     end
 
+    def run_direct
+      remaining_args = @args[1..] || []
+
+      # Find t-ruby executable path
+      t_ruby_bin = File.expand_path("../../bin/t-ruby", __dir__)
+
+      # Execute t-ruby (replaces current process)
+      exec(t_ruby_bin, *remaining_args)
+    end
+
     def start_watch_mode
       # Get paths to watch (everything after --watch or -w flag)
       watch_index = @args.index("--watch") || @args.index("-w")

data/lib/t_ruby/doc_generator.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "fileutils"
+require "time"
 
 module TRuby
   # API Documentation Generator

data/lib/t_ruby/docs_badge_generator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "time"
 require_relative "docs_example_verifier"
 
 module TRuby

data/lib/t_ruby/ir.rb

@@ -646,7 +646,13 @@ module TRuby
       end
 
       def to_rbs
-        "#{@inner_type.to_rbs}?"
+        inner_rbs = @inner_type.to_rbs
+        # Simple types can use ? suffix, complex types need (Type | nil) form
+        if @inner_type.is_a?(SimpleType)
+          "#{inner_rbs}?"
+        else
+          "(#{inner_rbs} | nil)"
+        end
       end
 
       def to_trb
@@ -829,77 +835,17 @@ module TRuby
         return nil unless type_str
 
         type_str = type_str.strip
+        return nil if type_str.empty?
 
-        # Union type
-        if type_str.include?("|")
-          types = type_str.split("|").map { |t| parse_type(t.strip) }
-          return UnionType.new(types: types)
-        end
-
-        # Intersection type
-        if type_str.include?("&")
-          types = type_str.split("&").map { |t| parse_type(t.strip) }
-          return IntersectionType.new(types: types)
-        end
+        # Use ParserCombinator::TypeParser for all type parsing
+        # Supports: simple types, generics, array shorthand, union, intersection, function types
+        @type_parser ||= TRuby::ParserCombinator::TypeParser.new
+        result = @type_parser.parse(type_str)
+        return result[:type] if result[:success]
 
-        # Nullable type
-        if type_str.end_with?("?")
-          inner = parse_type(type_str[0..-2])
-          return NullableType.new(inner_type: inner)
-        end
-
-        # Generic type
-        if type_str.include?("<") && type_str.include?(">")
-          match = type_str.match(/^(\w+)<(.+)>$/)
-          if match
-            base = match[1]
-            args = parse_generic_args(match[2])
-            return GenericType.new(base: base, type_args: args)
-          end
-        end
-
-        # Function type
-        if type_str.include?("->")
-          match = type_str.match(/^\((.*)?\)\s*->\s*(.+)$/)
-          if match
-            param_types = match[1] ? match[1].split(",").map { |t| parse_type(t.strip) } : []
-            return_type = parse_type(match[2])
-            return FunctionType.new(param_types: param_types, return_type: return_type)
-          end
-        end
-
-        # Simple type
+        # Fallback for unparseable types - return as SimpleType
         SimpleType.new(name: type_str)
       end
-
-      def parse_generic_args(args_str)
-        args = []
-        current = ""
-        depth = 0
-
-        args_str.each_char do |char|
-          case char
-          when "<"
-            depth += 1
-            current += char
-          when ">"
-            depth -= 1
-            current += char
-          when ","
-            if depth.zero?
-              args << parse_type(current.strip)
-              current = ""
-            else
-              current += char
-            end
-          else
-            current += char
-          end
-        end
-
-        args << parse_type(current.strip) unless current.empty?
-        args
-      end
     end
 
     #==========================================================================

data/lib/t_ruby/package_manager.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "net/http"
 require "uri"
+require "time"
 
 module TRuby
   # Semantic version parsing and comparison

data/lib/t_ruby/parser_combinator/token/token_declaration_parser.rb

@@ -781,6 +781,7 @@ module TRuby
         end
 
         # Check for tuple type: (Type, Type) -> ReturnType
+        # or parenthesized type: (String | Integer)[]
         if tokens[position].type == :lparen
           position += 1
           param_types = []
@@ -811,6 +812,11 @@ module TRuby
 
             node = IR::FunctionType.new(param_types: param_types, return_type: return_result.value)
             return TokenParseResult.success(node, tokens, return_result.position)
+          elsif param_types.length == 1
+            # Single type in parentheses: (String | Integer)
+            # Check for postfix operators like [] or ?
+            type = param_types[0]
+            return parse_postfix_type_operators(tokens, position, type)
           else
             node = IR::TupleType.new(element_types: param_types)
             return TokenParseResult.success(node, tokens, position)
@@ -826,6 +832,13 @@ module TRuby
         type_name = tokens[position].value
         position += 1
 
+        # Handle type names ending with ? (e.g., "String?" scanned as single token)
+        # This happens because Ruby allows ? in method/identifier names
+        is_nullable_from_name = type_name.end_with?("?")
+        if is_nullable_from_name
+          type_name = type_name.chomp("?")
+        end
+
         # Check for generic arguments: Type<Args>
         if position < tokens.length && tokens[position].type == :lt
           position += 1
@@ -848,17 +861,46 @@ module TRuby
           position += 1
 
           node = IR::GenericType.new(base: type_name, type_args: type_args)
-          TokenParseResult.success(node, tokens, position)
-        elsif position < tokens.length && tokens[position].type == :question
-          # Check for nullable: Type?
-          position += 1
-          inner = IR::SimpleType.new(name: type_name)
-          node = IR::NullableType.new(inner_type: inner)
-          TokenParseResult.success(node, tokens, position)
+          # Wrap in NullableType if the original type name ended with ?
+          node = IR::NullableType.new(inner_type: node) if is_nullable_from_name
+          # Apply postfix operators ([] or ?) to generic types too
+          parse_postfix_type_operators(tokens, position, node)
         else
+          # Simple type - apply postfix operators
           node = IR::SimpleType.new(name: type_name)
-          TokenParseResult.success(node, tokens, position)
+          # Wrap in NullableType if the original type name ended with ?
+          node = IR::NullableType.new(inner_type: node) if is_nullable_from_name
+          parse_postfix_type_operators(tokens, position, node)
+        end
+      end
+
+      # Parse postfix type operators: [] (array shorthand) and ? (nullable)
+      # Handles patterns like:
+      #   String[]     => Array<String>
+      #   Integer[][]  => Array<Array<Integer>>
+      #   String[]?    => NullableType(Array<String>)
+      #   String?[]    => Array<NullableType(String)>
+      #   (A | B)[]    => Array<UnionType(A, B)>
+      def parse_postfix_type_operators(tokens, position, type)
+        loop do
+          break if position >= tokens.length
+
+          case tokens[position].type
+          when :lbracket
+            # Check for [] (empty brackets for array shorthand)
+            break unless tokens[position + 1]&.type == :rbracket
+
+            position += 2
+            type = IR::GenericType.new(base: "Array", type_args: [type])
+          when :question
+            position += 1
+            type = IR::NullableType.new(inner_type: type)
+          else
+            break
+          end
         end
+
+        TokenParseResult.success(type, tokens, position)
       end
 
       # Parse hash literal type: { key: Type, key2: Type }

data/lib/t_ruby/parser_combinator/type_parser.rb

@@ -81,9 +81,24 @@ module TRuby
           generic_type
         )
 
-        # With optional nullable suffix
-        base_type = (primary_type >> nullable_suffix.optional).map do |(type, nullable)|
-          nullable ? IR::NullableType.new(inner_type: type) : type
+        # Array shorthand suffix: [] (can be repeated for nested arrays)
+        array_suffix = string("[]")
+
+        # Postfix operators: ([] | ?)*
+        # Handles: String[], Integer[][], String[]?, String?[], etc.
+        postfix_op = array_suffix | nullable_suffix
+
+        base_type = (primary_type >> postfix_op.many).map do |(initial_type, ops)|
+          ops.reduce(initial_type) do |type, op|
+            case op
+            when "[]"
+              IR::GenericType.new(base: "Array", type_args: [type])
+            when "?"
+              IR::NullableType.new(inner_type: type)
+            else
+              type
+            end
+          end
         end
 
         # Union type: Type | Type | ...

data/lib/t_ruby/runner.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module TRuby
+  # Thor-based CLI for t-ruby command
+  # Runs .trb files directly without generating intermediate files
+  class RunnerCLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    # Override Thor's default behavior to treat unknown arguments as the file to run
+    def self.start(given_args = ARGV, _config = {})
+      # Handle version flag
+      if given_args.include?("--version") || given_args.include?("-v")
+        new.version
+        return
+      end
+
+      # Handle help flag or no arguments
+      if given_args.empty? || given_args.include?("--help") || given_args.include?("-h")
+        new.help
+        return
+      end
+
+      # Treat first argument as file, rest as script arguments
+      file = given_args.first
+      args = given_args[1..] || []
+
+      runner = Runner.new
+      runner.run_file(file, args)
+    end
+
+    desc "FILE [ARGS...]", "Run a .trb file directly without generating files"
+    def run_file(file, *args)
+      runner = Runner.new
+      runner.run_file(file, args)
+    end
+
+    map %w[--version -v] => :version
+    desc "--version, -v", "Show version"
+    def version
+      puts "t-ruby #{VERSION}"
+    end
+
+    desc "--help, -h", "Show help"
+    def help
+      puts <<~HELP
+        t-ruby v#{VERSION} - Run T-Ruby files directly
+
+        Usage:
+          t-ruby <file.trb>              Run a .trb file directly
+          t-ruby <file.trb> [args...]    Run with arguments passed to the script
+          t-ruby --version, -v           Show version
+          t-ruby --help, -h              Show this help
+
+        Examples:
+          t-ruby hello.trb               Run hello.trb
+          t-ruby server.trb 8080         Run with argument 8080
+          t-ruby script.trb foo bar      Run with multiple arguments
+
+        Notes:
+          - No .rb or .rbs files are generated
+          - Type annotations are stripped at runtime
+          - Arguments after the file are passed to ARGV
+      HELP
+    end
+  end
+
+  # Runner class - executes T-Ruby code directly
+  # Can be used as a library or through RunnerCLI
+  class Runner
+    def initialize(config = nil)
+      @config = config || Config.new
+      @compiler = Compiler.new(@config)
+    end
+
+    # Run a .trb file directly
+    # @param input_path [String] Path to the .trb file
+    # @param argv [Array<String>] Arguments to pass to the script via ARGV
+    def run_file(input_path, argv = [])
+      unless File.exist?(input_path)
+        warn "Error: File not found: #{input_path}"
+        exit 1
+      end
+
+      source = File.read(input_path)
+      result = @compiler.compile_string(source)
+
+      if result[:errors].any?
+        result[:errors].each { |e| warn e }
+        exit 1
+      end
+
+      execute_ruby(result[:ruby], input_path, argv)
+    end
+
+    # Run T-Ruby source code from a string
+    # @param source [String] T-Ruby source code
+    # @param filename [String] Filename for error reporting
+    # @param argv [Array<String>] Arguments to pass via ARGV
+    # @return [Boolean] true if execution succeeded
+    def run_string(source, filename: "(t-ruby)", argv: [])
+      result = @compiler.compile_string(source)
+
+      if result[:errors].any?
+        result[:errors].each { |e| warn e }
+        return false
+      end
+
+      execute_ruby(result[:ruby], filename, argv)
+      true
+    end
+
+    private
+
+    # Execute Ruby code with proper script environment
+    # @param ruby_code [String] Ruby code to execute
+    # @param filename [String] Script filename (for $0 and stack traces)
+    # @param argv [Array<String>] Script arguments
+    def execute_ruby(ruby_code, filename, argv)
+      # Set up script environment
+      ARGV.replace(argv)
+      $0 = filename
+
+      # Execute using eval with filename and line number preserved
+      # This ensures stack traces point to the original .trb file
+      TOPLEVEL_BINDING.eval(ruby_code, filename, 1)
+    end
+  end
+end

data/lib/t_ruby/version.rb

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

data/lib/t_ruby.rb

@@ -29,6 +29,7 @@ require_relative "t_ruby/declaration_generator"
 require_relative "t_ruby/compiler"
 require_relative "t_ruby/lsp_server"
 require_relative "t_ruby/watcher"
+require_relative "t_ruby/runner"
 require_relative "t_ruby/cli"
 
 # Milestone 4: Advanced Features

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: t-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.43
+  version: 0.0.46
 platform: ruby
 authors:
 - Y. Fred Kim
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark
@@ -23,17 +24,33 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: t-ruby compiles .trb files with type annotations to executable Ruby (.rb)
   and optional type signature files (.rbs)
 email:
 - yhkks1038@gmail.com
 executables:
 - trc
+- t-ruby
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- bin/t-ruby
 - bin/trc
 - lib/t_ruby.rb
 - lib/t_ruby/ast_type_inferrer.rb
@@ -109,6 +126,7 @@ files:
 - lib/t_ruby/parser_combinator/token/token_skip_right.rb
 - lib/t_ruby/parser_combinator/type_parser.rb
 - lib/t_ruby/ruby_version.rb
+- lib/t_ruby/runner.rb
 - lib/t_ruby/runtime_validator.rb
 - lib/t_ruby/scanner.rb
 - lib/t_ruby/smt_solver.rb
@@ -127,6 +145,7 @@ licenses:
 - BSD-2-Clause
 metadata:
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,7 +160,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.1
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: T-Ruby - TypeScript-style types for Ruby
 test_files: []