rbs-relaxed 3.9.0.1

data/lib/rbs/ast/visitor.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    # The Visitor class implements the Visitor pattern for traversing the RBS Abstract Syntax Tree (AST).
+    #
+    # It provides methods to visit each type of node in the AST, allowing for custom processing of each node type.
+    #
+    # This class is designed to be subclassed, with specific visit methods overridden to implement custom behavior for
+    # different node types.
+    #
+    # Example usage:
+    #
+    # ~~~rb
+    # class MyVisitor < RBS::AST::Visitor
+    #   def visit_declaration_class(node)
+    #     puts "Visiting class: #{node.name}"
+    #
+    #     super # call `super` to run the default visiting behavior
+    #   end
+    # end
+    #
+    # visitor = MyVisitor.new
+    # visitor.visit(ast_node)
+    # ~~~
+    class Visitor
+      def visit(node)
+        case node
+        when Declarations::Global
+          visit_declaration_global(node)
+        when Declarations::Class
+          visit_declaration_class(node)
+        when Declarations::Module
+          visit_declaration_module(node)
+        when Declarations::Constant
+          visit_declaration_constant(node)
+        when Declarations::TypeAlias
+          visit_declaration_type_alias(node)
+        when Declarations::Interface
+          visit_declaration_interface(node)
+        when Members::Alias
+          visit_member_alias(node)
+        when Members::ClassInstanceVariable
+          visit_member_class_instance_variable(node)
+        when Members::ClassVariable
+          visit_member_class_variable(node)
+        when Members::InstanceVariable
+          visit_member_instance_variable(node)
+        when Members::Private
+          visit_member_private(node)
+        when Members::Public
+          visit_member_public(node)
+        when Members::MethodDefinition
+          visit_member_method_definition(node)
+        when Members::AttrReader
+          visit_member_attr_reader(node)
+        when Members::AttrWriter
+          visit_member_attr_writer(node)
+        when Members::AttrAccessor
+          visit_member_attr_accessor(node)
+        when Members::Include
+          visit_member_include(node)
+        when Members::Prepend
+          visit_member_prepend(node)
+        when Members::Extend
+          visit_member_extend(node)
+        end
+      end
+
+      def visit_all(nodes)
+        nodes.each do |node|
+          visit(node)
+        end
+      end
+
+      def visit_declaration_global(node)
+      end
+
+      def visit_declaration_class(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_module(node)
+        visit_all(node.members)
+      end
+
+      def visit_declaration_constant(node)
+      end
+
+      def visit_declaration_type_alias(node)
+      end
+
+      def visit_declaration_interface(node)
+        visit_all(node.members)
+      end
+
+      def visit_member_alias(node)
+      end
+
+      def visit_member_class_instance_variable(node)
+      end
+
+      def visit_member_class_variable(node)
+      end
+
+      def visit_member_instance_variable(node)
+      end
+
+      def visit_member_private(node)
+      end
+
+      def visit_member_public(node)
+      end
+
+      def visit_member_method_definition(node)
+      end
+
+      def visit_member_attr_reader(node)
+      end
+
+      def visit_member_attr_writer(node)
+      end
+
+      def visit_member_attr_accessor(node)
+      end
+
+      def visit_member_include(node)
+      end
+
+      def visit_member_prepend(node)
+      end
+
+      def visit_member_extend(node)
+      end
+    end
+  end
+end

data/lib/rbs/buffer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RBS
+  class Buffer
+    attr_reader :name
+    attr_reader :content
+
+    def initialize(name:, content:)
+      @name = name
+      @content = content
+    end
+
+    def lines
+      @lines ||= content.lines
+    end
+
+    def ranges
+      @ranges ||=
+        begin
+          @ranges = []
+          offset = 0
+          lines.each do |line|
+            size = line.size
+            range = offset...(offset+size)
+            @ranges << range
+            offset += size
+          end
+
+          if !content.end_with?("\n") && content.size > 0
+            @ranges[-1] = @ranges[-1].begin...(@ranges[-1].end+1)
+          end
+
+          @ranges
+        end
+    end
+
+    def pos_to_loc(pos)
+      index = ranges.bsearch_index do |range|
+        pos < range.end ? true : false
+      end
+
+      if index
+        [index + 1, pos - ranges[index].begin]
+      else
+        [ranges.size + 1, 0]
+      end
+    end
+
+    def loc_to_pos(loc)
+      line, column = loc
+
+      if range = ranges[line - 1]
+        range.begin + column
+      else
+        last_position
+      end
+    end
+
+    def last_position
+      content.size
+    end
+
+    def inspect
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{lines.size} lines,>"
+    end
+  end
+end

data/lib/rbs/builtin_names.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RBS
+  module BuiltinNames
+    class Name
+      attr_reader :name
+
+      def initialize(name:)
+        @name = name
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def instance_type(*args)
+        Types::ClassInstance.new(name: name, args: args, location: nil)
+      end
+
+      def instance_type?(type)
+        type.is_a?(Types::ClassInstance) && type.name == name
+      end
+
+      def singleton_type
+        @singleton_type ||= Types::ClassSingleton.new(name: name, location: nil)
+      end
+
+      def singleton_type?(type)
+        type.is_a?(Types::ClassSingleton) && type.name == name
+      end
+
+      def self.define(name, namespace: Namespace.root)
+        new(name: TypeName.new(name: name, namespace: namespace))
+      end
+    end
+
+    BasicObject = Name.new(name: TypeName.new(name: :BasicObject, namespace: Namespace.root))
+    Object = Name.new(name: TypeName.new(name: :Object, namespace: Namespace.root))
+    Kernel = Name.new(name: TypeName.new(name: :Kernel, namespace: Namespace.root))
+    String = Name.define(:String)
+    Comparable = Name.define(:Comparable)
+    Enumerable = Name.define(:Enumerable)
+    Class = Name.define(:Class)
+    Module = Name.define(:Module)
+    Array = Name.define(:Array)
+    Hash = Name.define(:Hash)
+    Range = Name.define(:Range)
+    Enumerator = Name.define(:Enumerator)
+    Set = Name.define(:Set)
+    Symbol = Name.define(:Symbol)
+    Integer = Name.define(:Integer)
+    Float = Name.define(:Float)
+    Regexp = Name.define(:Regexp)
+    TrueClass = Name.define(:TrueClass)
+    FalseClass = Name.define(:FalseClass)
+    Numeric = Name.define(:Numeric)
+  end
+end

data/lib/rbs/cli/colored_io.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader :stdout
+
+      def initialize(stdout:)
+        @stdout = stdout
+      end
+
+      def puts_red(string)
+        if can_display_colors?
+          puts "\e[31m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts_green(string)
+        if can_display_colors?
+          puts "\e[32m#{string}\e[m"
+        else
+          puts string
+        end
+      end
+
+      def puts(...)
+        stdout.puts(...)
+      end
+
+      private
+
+      # https://github.com/rubygems/rubygems/blob/ed65279100234a17d65d71fe26de5083984ac5b8/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb#L99-L109
+      def can_display_colors?
+        are_colors_supported? && !are_colors_disabled?
+      end
+
+      def are_colors_supported?
+        stdout.tty? && ENV["TERM"] != "dumb"
+      end
+
+      def are_colors_disabled?
+        !ENV['NO_COLOR'].nil? && !ENV.fetch('NO_COLOR', '').empty?
+      end
+    end
+  end
+end

data/lib/rbs/cli/diff.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RBS
+  class CLI
+    class Diff
+      def initialize(argv:, library_options:, stdout: $stdout, stderr: $stderr)
+        @format = nil
+        @stdout = stdout
+        @stderr = stderr
+
+        # @type var type_name: String?
+        type_name = nil
+        library_options = library_options
+        before_path = [] #: Array[String]
+        after_path = [] #: Array[String]
+        detail = false
+
+        opt = OptionParser.new do |o|
+          o.banner = <<~HELP
+            [Experimental] This command is experimental. API and output compatibility is not guaranteed.
+
+            Usage:
+              rbs diff --format markdown --type-name Foo --before before_sig --after after_sig
+
+            Print diff for rbs environment dir
+
+            Examples:
+
+              # Diff dir1 and dir2 for Foo
+              $ rbs diff --format markdown --type-name Foo --before dir1 --after dir2
+
+              # Confirmation of methods related to Time class added by including stdlib/time
+              $ rbs diff --format diff --type-name Time --after stdlib/time
+          HELP
+          o.on("--format NAME")    { |arg| @format = arg }
+          o.on("--type-name NAME") { |arg| type_name = arg }
+          o.on("--before DIR")     { |arg| before_path << arg }
+          o.on("--after DIR")      { |arg| after_path << arg }
+          o.on("--[no-]detail")    { |arg| detail = arg }
+        end
+        opt.parse!(argv)
+
+        unless @format && type_name && ["markdown", "diff"].include?(@format)
+          @stderr.puts opt.banner
+          exit 1
+        end
+
+        @diff = RBS::Diff.new(
+          type_name: TypeName.parse(type_name).absolute!,
+          library_options: library_options,
+          after_path: after_path,
+          before_path: before_path,
+          detail: detail,
+        )
+      end
+
+      def run
+        public_send("run_#{@format}")
+      end
+
+      def run_diff
+        first = true
+        io = RBS::CLI::ColoredIO.new(stdout: @stdout)
+        @diff.each_diff do |before, after|
+          io.puts if !first
+          io.puts_red   "- #{before}"
+          io.puts_green "+ #{after}"
+          first = false
+        end
+      end
+
+      def run_markdown
+        @stdout.puts "| before | after |"
+        @stdout.puts "| --- | --- |"
+        @diff.each_diff do |before, after|
+          before.gsub!("|", "\\|")
+          after.gsub!("|", "\\|")
+          @stdout.puts "| `#{before}` | `#{after}` |"
+        end
+      end
+    end
+  end
+end