t-ruby 0.0.34 → 0.0.36

data/lib/t_ruby/package_manager.rb

@@ -12,7 +12,7 @@ module TRuby
 
     attr_reader :major, :minor, :patch, :prerelease
 
-    VERSION_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/.freeze
+    VERSION_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/
 
     def initialize(version_string)
       match = VERSION_REGEX.match(version_string.to_s)
@@ -115,9 +115,8 @@ module TRuby
   class PackageManifest
     MANIFEST_FILE = ".trb-manifest.json"
 
-    attr_accessor :name, :version, :description, :author, :license
-    attr_accessor :types, :dependencies, :dev_dependencies
-    attr_accessor :repository, :keywords, :main
+    attr_accessor :name, :version, :description, :author, :license, :types, :dependencies, :dev_dependencies,
+                  :repository, :keywords, :main
 
     def initialize(data = {})
       @name = data[:name] || data["name"]
@@ -145,11 +144,11 @@ module TRuby
         devDependencies: @dev_dependencies,
         repository: @repository,
         keywords: @keywords,
-        main: @main
+        main: @main,
       }.compact
     end
 
-    def to_json(*args)
+    def to_json(*_args)
       JSON.pretty_generate(to_h)
     end
 
@@ -310,7 +309,7 @@ module TRuby
           name: pkg["name"],
           version: pkg["version"],
           downloads: pkg["downloads"],
-          summary: pkg["info"] || pkg["summary"]
+          summary: pkg["info"] || pkg["summary"],
         }
       end
     rescue StandardError => e
@@ -333,7 +332,7 @@ module TRuby
         source_code: response["source_code_uri"],
         documentation: response["documentation_uri"],
         licenses: response["licenses"],
-        dependencies: parse_dependencies(response["dependencies"])
+        dependencies: parse_dependencies(response["dependencies"]),
       }
     rescue StandardError => e
       warn "Failed to fetch package info: #{e.message}"
@@ -351,7 +350,7 @@ module TRuby
           number: v["number"],
           created_at: v["created_at"],
           prerelease: v["prerelease"],
-          sha: v["sha"]
+          sha: v["sha"],
         }
       end
     rescue StandardError => e
@@ -432,8 +431,6 @@ module TRuby
       case response
       when Net::HTTPSuccess
         JSON.parse(response.body)
-      else
-        nil
       end
     rescue StandardError
       nil
@@ -484,7 +481,7 @@ module TRuby
       result
     end
 
-    def extract_types(gem_path, target_dir)
+    def extract_types(_gem_path, target_dir)
       # In a real implementation, would extract .d.trb files from gem
       # For now, just create marker
       File.write(File.join(target_dir, ".extracted"), Time.now.iso8601)
@@ -508,7 +505,7 @@ module TRuby
       @packages[manifest.name] ||= {}
       @packages[manifest.name][manifest.version] = {
         dependencies: manifest.dependencies,
-        types: manifest.types
+        types: manifest.types,
       }
     end
 
@@ -524,6 +521,7 @@ module TRuby
       if version == "*"
         latest = get_versions(name).map { |v| SemanticVersion.parse(v) }.compact.max
         return nil unless latest
+
         version = latest.to_s
       end
 
@@ -549,7 +547,7 @@ module TRuby
       return nil unless pkg
 
       # Copy type definitions
-      types_pattern = pkg[:types] || "**/*.d.trb"
+      pkg[:types] || "**/*.d.trb"
       # In real implementation, would download from registry
 
       { name: name, version: version, path: target }
@@ -616,7 +614,7 @@ module TRuby
       result = @resolver.resolve(@manifest)
 
       if result[:conflicts].any?
-        raise "Dependency conflicts: #{result[:conflicts].join(', ')}"
+        raise "Dependency conflicts: #{result[:conflicts].join(", ")}"
       end
 
       installed = []
@@ -681,7 +679,7 @@ module TRuby
       {
         name: @manifest.name,
         version: @manifest.version,
-        status: :published
+        status: :published,
       }
     end
 
@@ -693,7 +691,7 @@ module TRuby
         package: @manifest.name,
         version: version,
         deprecated: true,
-        message: message
+        message: message,
       }
     end
 
@@ -709,7 +707,7 @@ module TRuby
       lockfile = {
         lockfileVersion: 1,
         packages: resolved,
-        generatedAt: Time.now.iso8601
+        generatedAt: Time.now.iso8601,
       }
 
       File.write(

data/lib/t_ruby/parser.rb

@@ -55,7 +55,7 @@ module TRuby
         type: :success,
         functions: functions,
         type_aliases: type_aliases,
-        interfaces: interfaces
+        interfaces: interfaces,
       }
 
       # Build IR if combinator is enabled
@@ -97,14 +97,14 @@ module TRuby
           return {
             name: alias_name,
             definition: definition,
-            ir_type: type_result[:type]
+            ir_type: type_result[:type],
           }
         end
       end
 
       {
         name: alias_name,
-        definition: definition
+        definition: definition,
       }
     end
 
@@ -126,7 +126,7 @@ module TRuby
       result = {
         name: function_name,
         params: params,
-        return_type: return_type_str
+        return_type: return_type_str,
       }
 
       # Parse return type with combinator if available
@@ -195,7 +195,7 @@ module TRuby
           depth -= 1
           current += char
         when ","
-          if depth == 0
+          if depth.zero?
             result << current.strip
             current = ""
           else
@@ -219,7 +219,7 @@ module TRuby
 
       result = {
         name: param_name,
-        type: type_str
+        type: type_str,
       }
 
       # Parse type with combinator if available
@@ -249,7 +249,7 @@ module TRuby
           if member_match
             member = {
               name: member_match[1],
-              type: member_match[2].strip
+              type: member_match[2].strip,
             }
 
             # Parse member type with combinator

data/lib/t_ruby/parser_combinator.rb

@@ -32,11 +32,13 @@ module TRuby
 
       def map
         return self if failure?
+
         ParseResult.success(yield(value), remaining, position)
       end
 
       def flat_map
         return self if failure?
+
         yield(value, remaining, position)
       end
     end
@@ -167,7 +169,7 @@ module TRuby
         remaining = input[position..]
         match = @pattern.match(remaining)
 
-        if match && match.begin(0) == 0
+        if match&.begin(0)&.zero?
           matched = match[0]
           ParseResult.success(matched, input, position + matched.length)
         else
@@ -303,6 +305,7 @@ module TRuby
 
           results << result.value
           break if result.position == current_pos # Prevent infinite loop
+
           current_pos = result.position
         end
 
@@ -329,6 +332,7 @@ module TRuby
 
           results << result.value
           break if result.position == current_pos
+
           current_pos = result.position
         end
 
@@ -567,8 +571,8 @@ module TRuby
         Fail.new(message)
       end
 
-      def lazy(&block)
-        Lazy.new(&block)
+      def lazy(&)
+        Lazy.new(&)
       end
 
       def choice(*parsers)
@@ -597,11 +601,11 @@ module TRuby
       end
 
       def spaces
-        whitespace.many.map { |chars| chars.join }
+        whitespace.many.map(&:join)
       end
 
       def spaces1
-        whitespace.many1.map { |chars| chars.join }
+        whitespace.many1.map(&:join)
       end
 
       def newline
@@ -622,7 +626,7 @@ module TRuby
       end
 
       def float
-        regex(/\-?\d+\.\d+/, "float").map(&:to_f)
+        regex(/-?\d+\.\d+/, "float").map(&:to_f)
       end
 
       def quoted_string(quote = '"')
@@ -670,7 +674,7 @@ module TRuby
         type_name = identifier.label("type name")
 
         # Simple type
-        simple_type = type_name.map { |name| IR::SimpleType.new(name: name) }
+        type_name.map { |name| IR::SimpleType.new(name: name) }
 
         # Lazy reference for recursive types
         type_expr = lazy { @type_expr }
@@ -778,15 +782,15 @@ module TRuby
 
       def build_parsers
         # Type expression (delegate to TypeParser)
-        type_expr = lazy { parse_type_inline }
+        lazy { parse_type_inline }
 
         # Keywords
         kw_type = lexeme(string("type"))
         kw_interface = lexeme(string("interface"))
         kw_def = lexeme(string("def"))
         kw_end = lexeme(string("end"))
-        kw_class = lexeme(string("class"))
-        kw_module = lexeme(string("module"))
+        lexeme(string("class"))
+        lexeme(string("module"))
 
         # Type alias: type Name = Definition
         type_alias = (
@@ -798,8 +802,6 @@ module TRuby
           type_result = @type_parser.parse(definition)
           if type_result[:success]
             IR::TypeAlias.new(name: name, definition: type_result[:type])
-          else
-            nil
           end
         end
 
@@ -812,8 +814,6 @@ module TRuby
           type_result = @type_parser.parse(type_str)
           if type_result[:success]
             IR::InterfaceMember.new(name: name, type_signature: type_result[:type])
-          else
-            nil
           end
         end
 
@@ -836,10 +836,10 @@ module TRuby
           (lexeme(char(":")) >> regex(/[^,)]+/).map(&:strip)).optional
         ).map do |(name, type_str)|
           type_node = if type_str
-            type_str_val = type_str.is_a?(Array) ? type_str.last : type_str
-            result = @type_parser.parse(type_str_val)
-            result[:success] ? result[:type] : nil
-          end
+                        type_str_val = type_str.is_a?(Array) ? type_str.last : type_str
+                        result = @type_parser.parse(type_str_val)
+                        result[:success] ? result[:type] : nil
+                      end
           IR::Parameter.new(name: name, type_annotation: type_node)
         end
 
@@ -864,9 +864,9 @@ module TRuby
           return_type
         ).map do |(((_, name), params), ret_str)|
           ret_type = if ret_str
-            result = @type_parser.parse(ret_str)
-            result[:success] ? result[:type] : nil
-          end
+                       result = @type_parser.parse(ret_str)
+                       result[:success] ? result[:type] : nil
+                     end
           IR::MethodDef.new(
             name: name,
             params: params || [],
@@ -922,7 +922,7 @@ module TRuby
           result << "#{prefix}#{i + 1}: #{input_lines[i]}"
 
           if i == @line - 1
-            result << "    " + " " * (@column + @line.to_s.length + 1) + "^"
+            result << "    #{" " * (@column + @line.to_s.length + 1)}^"
           end
         end
 

data/lib/t_ruby/rbs_generator.rb

@@ -7,11 +7,9 @@ module TRuby
     end
 
     def generate(functions, type_aliases)
-      lines = []
-
       # Add type aliases
-      type_aliases.each do |type_alias|
-        lines << generate_type_alias(type_alias)
+      lines = type_aliases.map do |type_alias|
+        generate_type_alias(type_alias)
       end
 
       lines << "" if type_aliases.any? && functions.any?

data/lib/t_ruby/runtime_validator.rb

@@ -3,8 +3,7 @@
 module TRuby
   # Configuration for runtime validation
   class ValidationConfig
-    attr_accessor :validate_all, :validate_public_only, :raise_on_error
-    attr_accessor :log_violations, :strict_mode
+    attr_accessor :validate_all, :validate_public_only, :raise_on_error, :log_violations, :strict_mode
 
     def initialize
       @validate_all = true
@@ -39,7 +38,7 @@ module TRuby
       "Time" => ".is_a?(Time)",
       "Date" => ".is_a?(Date)",
       "IO" => ".is_a?(IO)",
-      "File" => ".is_a?(File)"
+      "File" => ".is_a?(File)",
     }.freeze
 
     def initialize(config = nil)
@@ -128,7 +127,7 @@ module TRuby
     def generate_union_check(var_name, union_type)
       types = union_type.split("|").map(&:strip)
       checks = types.map { |t| generate_type_check(var_name, t) }
-      "(#{checks.join(' || ')})"
+      "(#{checks.join(" || ")})"
     end
 
     # Generate generic type check
@@ -141,16 +140,19 @@ module TRuby
 
       case container_type
       when "Array"
-        "#{var_name}.is_a?(Array) && #{var_name}.all? { |_e| #{generate_type_check('_e', element_type)} }"
+        "#{var_name}.is_a?(Array) && #{var_name}.all? { |_e| #{generate_type_check("_e", element_type)} }"
       when "Hash"
         if element_type.include?(",")
           key_type, value_type = element_type.split(",").map(&:strip)
-          "#{var_name}.is_a?(Hash) && #{var_name}.all? { |_k, _v| #{generate_type_check('_k', key_type)} && #{generate_type_check('_v', value_type)} }"
+          "#{var_name}.is_a?(Hash) && #{var_name}.all? { |_k, _v| #{generate_type_check("_k",
+                                                                                        key_type)} && #{generate_type_check(
+                                                                                          "_v", value_type
+                                                                                        )} }"
         else
           "#{var_name}.is_a?(Hash)"
         end
       when "Set"
-        "#{var_name}.is_a?(Set) && #{var_name}.all? { |_e| #{generate_type_check('_e', element_type)} }"
+        "#{var_name}.is_a?(Set) && #{var_name}.all? { |_e| #{generate_type_check("_e", element_type)} }"
       else
         # Generic with unknown container - just check container type
         "#{var_name}.is_a?(#{container_type})"
@@ -161,7 +163,7 @@ module TRuby
     def generate_intersection_check(var_name, intersection_type)
       types = intersection_type.split("&").map(&:strip)
       checks = types.map { |t| generate_type_check(var_name, t) }
-      "(#{checks.join(' && ')})"
+      "(#{checks.join(" && ")})"
     end
 
     # Generate return value validation wrapper
@@ -169,7 +171,7 @@ module TRuby
       {
         type: :return,
         check: generate_type_check("_result", return_type),
-        return_type: return_type
+        return_type: return_type,
       }
     end
 
@@ -186,7 +188,7 @@ module TRuby
         @function_validations[func[:name]] = generate_function_validation(func)
       end
 
-      lines.each_with_index do |line, idx|
+      lines.each_with_index do |line, _idx|
         # Check for function definition
         if line.match?(/^\s*def\s+(\w+)/)
           match = line.match(/^(\s*)def\s+(\w+)/)
@@ -201,7 +203,7 @@ module TRuby
             param_validations = validations.select { |v| v.is_a?(String) }
 
             param_validations.each do |validation|
-              output_lines << "#{' ' * (function_indent + 2)}#{validation}"
+              output_lines << "#{" " * (function_indent + 2)}#{validation}"
             end
           end
 
@@ -233,34 +235,34 @@ module TRuby
       RUBY
 
       module_code += <<~RUBY
-            case expected_type
-            when "String"
-              raise TypeError, "\#{param_name} must be String, got \#{value.class}" unless value.is_a?(String)
-            when "Integer"
-              raise TypeError, "\#{param_name} must be Integer, got \#{value.class}" unless value.is_a?(Integer)
-            when "Float"
-              raise TypeError, "\#{param_name} must be Float, got \#{value.class}" unless value.is_a?(Float)
-            when "Boolean"
-              raise TypeError, "\#{param_name} must be Boolean, got \#{value.class}" unless value == true || value == false
-            when "Symbol"
-              raise TypeError, "\#{param_name} must be Symbol, got \#{value.class}" unless value.is_a?(Symbol)
-            when "Array"
-              raise TypeError, "\#{param_name} must be Array, got \#{value.class}" unless value.is_a?(Array)
-            when "Hash"
-              raise TypeError, "\#{param_name} must be Hash, got \#{value.class}" unless value.is_a?(Hash)
-            when "nil"
-              raise TypeError, "\#{param_name} must be nil, got \#{value.class}" unless value.nil?
-            else
-              # Custom type check
-              begin
-                type_class = Object.const_get(expected_type)
-                raise TypeError, "\#{param_name} must be \#{expected_type}, got \#{value.class}" unless value.is_a?(type_class)
-              rescue NameError
-                # Unknown type, skip validation
-              end
+          case expected_type
+          when "String"
+            raise TypeError, "\#{param_name} must be String, got \#{value.class}" unless value.is_a?(String)
+          when "Integer"
+            raise TypeError, "\#{param_name} must be Integer, got \#{value.class}" unless value.is_a?(Integer)
+          when "Float"
+            raise TypeError, "\#{param_name} must be Float, got \#{value.class}" unless value.is_a?(Float)
+          when "Boolean"
+            raise TypeError, "\#{param_name} must be Boolean, got \#{value.class}" unless value == true || value == false
+          when "Symbol"
+            raise TypeError, "\#{param_name} must be Symbol, got \#{value.class}" unless value.is_a?(Symbol)
+          when "Array"
+            raise TypeError, "\#{param_name} must be Array, got \#{value.class}" unless value.is_a?(Array)
+          when "Hash"
+            raise TypeError, "\#{param_name} must be Hash, got \#{value.class}" unless value.is_a?(Hash)
+          when "nil"
+            raise TypeError, "\#{param_name} must be nil, got \#{value.class}" unless value.nil?
+          else
+            # Custom type check
+            begin
+              type_class = Object.const_get(expected_type)
+              raise TypeError, "\#{param_name} must be \#{expected_type}, got \#{value.class}" unless value.is_a?(type_class)
+            rescue NameError
+              # Unknown type, skip validation
             end
-            true
           end
+          true
+        end
       RUBY
 
       # Generate validation methods for each function
@@ -274,6 +276,7 @@ module TRuby
 
         func[:params].each do |param|
           next unless param[:type]
+
           module_code += "    validate_type(#{param[:name]}, #{param[:type].inspect}, #{param[:name].inspect})\n"
         end
 
@@ -288,6 +291,7 @@ module TRuby
     def should_validate?(visibility)
       return true if @config.validate_all
       return visibility == :public if @config.validate_public_only
+
       false
     end
   end