t-ruby 0.0.7 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 054211b0b7c63b2f1b66b3cfed976385174c1b3f5904ea04357599b3c7440e8f
-  data.tar.gz: 0aa86d48811cff1bc7d7652155055f5041c0bef8e372b9dcec4a06a716534799
+  metadata.gz: aaa0445c84cb0a6685e788645a19fee5d30d2f1e6f79052122fb16e8a3f08e91
+  data.tar.gz: 446845b5b1e470964f664d590197262f0e3555b82dd59f7b75a484324b99ec63
 SHA512:
-  metadata.gz: 73ba77dc237a8455dd60b0c098de4372cd6e9f76e00619a54669af04fd46deca80c8c6fb1c3322114442ea38a471f18f722fc66018ad14cf31469ed153c11bc8
-  data.tar.gz: 5b6c3d2d3a895f941949d79407cb2e0ce91c3d1b3a13d7e113cd02be1a8fbdd9a82fb86bf6ac1d99832d4e331861c8657b516836b334aa73c8175273835c6da5
+  metadata.gz: e422c5535edcb5085efd7018825c1675b06b3c2bb3657da1c6d9f6b07202233b53c03c145888fbdc221fc78df4873d18c2d0f4326d19ede16134eda409fb7418
+  data.tar.gz: 0d988eaa6c08a586af4c965447087467e500cc75de4d7bc879c239c3f6924caf504123fc3117ed9be4e676b0ae2715bdadf888218e8072702c1a66bbb329a288

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,9 @@ 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 --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)
@@ -15,8 +18,11 @@ 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 -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
         trc --decl hello.trb     Generate hello.d.trb declaration file
         trc --lsp                Start language server for VS Code
@@ -41,6 +47,11 @@ module TRuby
         return
       end
 
+      if @args.include?("--init")
+        init_project
+        return
+      end
+
       if @args.include?("--lsp")
         start_lsp_server
         return
@@ -57,12 +68,95 @@ 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
 
+    def init_project
+      config_file = "trbconfig.yml"
+      src_dir = "src"
+      build_dir = "build"
+
+      created = []
+      skipped = []
+
+      # Create trbconfig.yml with new schema
+      if File.exist?(config_file)
+        skipped << config_file
+      else
+        File.write(config_file, <<~YAML)
+          # 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
+
+      # 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
@@ -92,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)
@@ -102,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

@@ -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)
@@ -42,22 +47,73 @@ 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
 
       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 +222,38 @@ 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.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
+    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