rbs 1.6.1 → 1.7.0.beta.3

data/lib/rbs/collection/sources/git.rb

@@ -1,5 +1,6 @@
 require 'digest/sha2'
 require 'open3'
+require 'find'
 
 module RBS
   module Collection
@@ -52,12 +53,26 @@ module RBS
         private def _install(dest:, config_entry:)
           gem_name = config_entry['name']
           version = config_entry['version'] or raise
-          dest = dest.join(gem_name)
+          dest = dest.join(gem_name, version)
           dest.mkpath
           src = gem_repo_dir.join(gem_name, version)
 
-          FileUtils.cp_r(src, dest)
-          dest.join(version, METADATA_FILENAME).write(YAML.dump(config_entry))
+          cp_r(src, dest)
+          dest.join(METADATA_FILENAME).write(YAML.dump(config_entry))
+        end
+
+        private def cp_r(src, dest)
+          Find.find(src) do |file_src|
+            file_src = Pathname(file_src)
+
+            # Skip file if it starts with _, such as _test/
+            Find.prune if file_src.basename.to_s.start_with?('_')
+
+            file_src_relative = file_src.relative_path_from(src)
+            file_dest = dest.join(file_src_relative)
+            file_dest.dirname.mkpath
+            FileUtils.copy_entry(file_src, file_dest, false, true) unless file_src.directory?
+          end
         end
 
         def to_lockfile

data/lib/rbs/errors.rb

@@ -15,10 +15,37 @@ module RBS
   end
 
   class ErrorBase < StandardError; end
-  class ParsingError < ErrorBase; end
   class LoadingError < ErrorBase; end
   class DefinitionError < ErrorBase; end
 
+  class ParsingError < ErrorBase
+    attr_reader :location
+    attr_reader :error_message
+    attr_reader :token_type
+
+    def initialize(location, error_message, token_type)
+      @location = location
+      @error_message = error_message
+      @token_type = token_type
+
+      super "#{Location.to_string location}: Syntax error: #{error_message}, token=`#{location.source}` (#{token_type})"
+    end
+
+    def error_value
+      RBS.print_warning {
+        "#{self.class.name}#error_value is deprecated and will be deleted in RBS 2.0. Consider using `location.source` instead."
+      }
+      location.source
+    end
+
+    def token_str
+      RBS.print_warning {
+        "#{self.class.name}#token_str is deprecated and will be deleted in RBS 2.0. Consider using `token_type` instead."
+      }
+      token_type
+    end
+  end
+
   class InvalidTypeApplicationError < DefinitionError
     attr_reader :type_name
     attr_reader :args

data/lib/rbs/location.rb

@@ -1,217 +1,221 @@
-module RBS
-  class Location
-    attr_reader :buffer
-    attr_reader :start_pos
-    attr_reader :end_pos
-
-    def initialize(buffer:, start_pos:, end_pos:)
-      @buffer = buffer
-      @start_pos = start_pos
-      @end_pos = end_pos
-    end
-
-    def inspect
-      "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
-    end
-
-    def name
-      buffer.name
-    end
-
-    def start_line
-      start_loc[0]
-    end
-
-    def start_column
-      start_loc[1]
-    end
-
-    def end_line
-      end_loc[0]
-    end
-
-    def end_column
-      end_loc[1]
-    end
-
-    def start_loc
-      @start_loc ||= buffer.pos_to_loc(start_pos)
-    end
-
-    def end_loc
-      @end_loc ||= buffer.pos_to_loc(end_pos)
-    end
-
-    def range
-      start_pos...end_pos
-    end
-
-    def source
-      @source ||= buffer.content[start_pos...end_pos] or raise
-    end
-
-    def to_s
-      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
-    end
-
-    def self.to_string(location, default: "*:*:*...*:*")
-      location&.to_s || default
-    end
-
-    def ==(other)
-      other.is_a?(Location) &&
-        other.buffer == buffer &&
-        other.start_pos == start_pos &&
-        other.end_pos == end_pos
-    end
-
-    def +(other)
-      if other
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-
-        self.class.new(buffer: buffer,
-                       start_pos: start_pos,
-                       end_pos: other.end_pos)
-      else
-        self
-      end
-    end
-
-    def concat(*others)
-      others.each { |other| self << other }
-      self
-    end
-
-    def <<(other)
-      if other
-        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
-        @end_pos = other.end_pos
-        @source = nil
-        @end_loc = nil
-      end
-      self
-    end
-
-    def pred?(loc)
-      loc.is_a?(Location) &&
-        loc.name == name &&
-        loc.start_pos == end_pos
-    end
-
-    def to_json(state = _ = nil)
-      {
-        start: {
-          line: start_line,
-          column: start_column
-        },
-        end: {
-          line: end_line,
-          column: end_column
-        },
-        buffer: {
-          name: name&.to_s
-        }
-      }.to_json(state)
-    end
-
-    def with_children(required: {}, optional: {})
-      # @type var required: Hash[Symbol, Range[Integer] | Location]
-      # @type var optional: Hash[Symbol, Range[Integer] | Location | nil]
-
-      this = WithChildren.new(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
-
-      req = required.transform_values do |value|
-        case value
-        when Location
-          value.range
-        else
-          value
-        end
-      end
-
-      opt = optional.transform_values do |value|
-        case value
-        when Location
-          value.range
-        else
-          value
-        end
-      end
-
-      this.required_children.merge!(req)
-      this.optional_children.merge!(opt)
-
-      this
-    end
-
-    class WithChildren < Location
-      attr_reader :required_children, :optional_children
-
-      def initialize(buffer:, start_pos:, end_pos:)
-        super(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
-
-        @optional_children = {}
-        @required_children = {}
-      end
-
-      def initialize_copy(from)
-        required_children.merge!(from.required_children)
-        optional_children.merge!(from.optional_children)
-        self
-      end
-
-      def [](key)
-        case
-        when required_children.key?(_ = key)
-          range = required_children[_ = key]
-          Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
-        when optional_children.key?(_ = key)
-          range = required_children[_ = key] || optional_children[_ = key]
-          if range
-            Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
-          end
-        else
-          raise "Unknown key given: `#{key}`"
-        end
-      end
-
-      def merge_required(hash)
-        this = dup
-
-        h = hash.transform_values do |value|
-          case value
-          when Range
-            value
-          when Location
-            value.range
-          else
-            raise
-          end
-        end
-
-        this.required_children.merge!(h)
-
-        this
-      end
-
-      def merge_optional(hash)
-        this = dup
-
-        h = hash.transform_values do |value|
-          case value
-          when Range
-            value
-          when Location
-            value.range
-          else
-            nil
-          end
-        end
-
-        this.optional_children.merge!(h)
-
-        this
-      end
-    end
-  end
-end
+# module RBS
+#   class Location
+#     attr_reader :buffer
+#     attr_reader :start_pos
+#     attr_reader :end_pos
+
+#     def initialize(buffer, start_pos, end_pos)
+#       @buffer = buffer
+#       @start_pos = start_pos
+#       @end_pos = end_pos
+#     end
+
+#     # def self.new(buffer_ = nil, start_pos_ = nil, end_pos_ = nil)
+#     #   __skip__ = super(buffer_, start_pos_, end_pos_)
+#     # end
+
+#     # def inspect
+#     #   "#<#{self.class}:#{self.__id__} @buffer=#{buffer.name}, @pos=#{start_pos}...#{end_pos}, source='#{source.lines.first}', start_line=#{start_line}, start_column=#{start_column}>"
+#     # end
+
+#     def name
+#       buffer.name
+#     end
+
+#     def start_line
+#       start_loc[0]
+#     end
+
+#     def start_column
+#       start_loc[1]
+#     end
+
+#     def end_line
+#       end_loc[0]
+#     end
+
+#     def end_column
+#       end_loc[1]
+#     end
+
+#     def start_loc
+#       @start_loc ||= buffer.pos_to_loc(start_pos)
+#     end
+
+#     def end_loc
+#       @end_loc ||= buffer.pos_to_loc(end_pos)
+#     end
+
+#     def range
+#       start_pos...end_pos
+#     end
+
+#     def source
+#       @source ||= buffer.content[start_pos...end_pos] or raise
+#     end
+
+#     def to_s
+#       "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
+#     end
+
+#     def self.to_string(location, default: "*:*:*...*:*")
+#       location&.to_s || default
+#     end
+
+#     def ==(other)
+#       other.is_a?(Location) &&
+#         other.buffer == buffer &&
+#         other.start_pos == start_pos &&
+#         other.end_pos == end_pos
+#     end
+
+#     def +(other)
+#       if other
+#         raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+
+#         self.class.new(buffer: buffer,
+#                        start_pos: start_pos,
+#                        end_pos: other.end_pos)
+#       else
+#         self
+#       end
+#     end
+
+#     def concat(*others)
+#       others.each { |other| self << other }
+#       self
+#     end
+
+#     def <<(other)
+#       if other
+#         raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+#         @end_pos = other.end_pos
+#         @source = nil
+#         @end_loc = nil
+#       end
+#       self
+#     end
+
+#     def pred?(loc)
+#       loc.is_a?(Location) &&
+#         loc.name == name &&
+#         loc.start_pos == end_pos
+#     end
+
+#     def to_json(state = _ = nil)
+#       {
+#         start: {
+#           line: start_line,
+#           column: start_column
+#         },
+#         end: {
+#           line: end_line,
+#           column: end_column
+#         },
+#         buffer: {
+#           name: name&.to_s
+#         }
+#       }.to_json(state)
+#     end
+
+#     def with_children(required: {}, optional: {})
+#       # @type var required: Hash[Symbol, Range[Integer] | Location]
+#       # @type var optional: Hash[Symbol, Range[Integer] | Location | nil]
+
+#       this = WithChildren.new(buffer: buffer, start_pos: start_pos, end_pos: end_pos)
+
+#       req = required.transform_values do |value|
+#         case value
+#         when Location
+#           value.range
+#         else
+#           value
+#         end
+#       end
+
+#       opt = optional.transform_values do |value|
+#         case value
+#         when Location
+#           value.range
+#         else
+#           value
+#         end
+#       end
+
+#       this.required_children.merge!(req)
+#       this.optional_children.merge!(opt)
+
+#       this
+#     end
+
+#     class WithChildren < Location
+#       attr_reader :required_children, :optional_children
+
+#       def initialize(buffer, start_pos, end_pos)
+#         super(buffer, start_pos, end_pos)
+
+#         @optional_children = {}
+#         @required_children = {}
+#       end
+
+#       def initialize_copy(from)
+#         required_children.merge!(from.required_children)
+#         optional_children.merge!(from.optional_children)
+#         self
+#       end
+
+#       def [](key)
+#         case
+#         when required_children.key?(_ = key)
+#           range = required_children[_ = key]
+#           Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+#         when optional_children.key?(_ = key)
+#           range = required_children[_ = key] || optional_children[_ = key]
+#           if range
+#             Location.new(buffer: buffer, start_pos: range.begin, end_pos: range.end)
+#           end
+#         else
+#           raise "Unknown key given: `#{key}`"
+#         end
+#       end
+
+#       def merge_required(hash)
+#         this = dup
+
+#         h = hash.transform_values do |value|
+#           case value
+#           when Range
+#             value
+#           when Location
+#             value.range
+#           else
+#             raise
+#           end
+#         end
+
+#         this.required_children.merge!(h)
+
+#         this
+#       end
+
+#       def merge_optional(hash)
+#         this = dup
+
+#         h = hash.transform_values do |value|
+#           case value
+#           when Range
+#             value
+#           when Location
+#             value.range
+#           else
+#             nil
+#           end
+#         end
+
+#         this.optional_children.merge!(h)
+
+#         this
+#       end
+#     end
+#   end
+# end

data/lib/rbs/location_aux.rb

@@ -0,0 +1,121 @@
+module RBS
+  class Location
+    def inspect
+      rks = each_required_key.to_a
+      ops = each_optional_key.to_a.map {|x| "?#{x}" }
+      "#<#{self.class}:#{self.__id__} buffer=#{buffer.name}, start=#{start_line}:#{start_column}, pos=#{start_pos}...#{end_pos}, children=#{(rks + ops).join(",")} source='#{source.lines.first&.chomp}'>"
+    end
+
+    def self.new(buffer_ = nil, start_pos_ = nil, end_pos_ = nil, buffer: nil, start_pos: nil, end_pos: nil)
+      __skip__ =
+        begin
+          if buffer && start_pos && end_pos
+            super(buffer, start_pos, end_pos)
+          else
+            super(buffer_, start_pos_, end_pos_)
+          end
+        end
+    end
+
+    WithChildren = self
+
+    def name
+      buffer.name
+    end
+
+    def start_line
+      start_loc[0]
+    end
+
+    def start_column
+      start_loc[1]
+    end
+
+    def end_line
+      end_loc[0]
+    end
+
+    def end_column
+      end_loc[1]
+    end
+
+    def start_loc
+      @start_loc ||= begin
+        _start_loc || buffer.pos_to_loc(start_pos)
+      end
+    end
+
+    def end_loc
+      @end_loc ||= begin
+        _end_loc || buffer.pos_to_loc(end_pos)
+      end
+    end
+
+    def range
+      @range ||= start_pos...end_pos
+    end
+
+    def source
+      @source ||= buffer.content[range] or raise
+    end
+
+    def to_s
+      "#{name || "-"}:#{start_line}:#{start_column}...#{end_line}:#{end_column}"
+    end
+
+    def ==(other)
+      other.is_a?(Location) &&
+        other.buffer == buffer &&
+        other.start_pos == start_pos &&
+        other.end_pos == end_pos
+    end
+
+    def to_json(state = _ = nil)
+      {
+        start: {
+          line: start_line,
+          column: start_column
+        },
+        end: {
+          line: end_line,
+          column: end_column
+        },
+        buffer: {
+          name: name&.to_s
+        }
+      }.to_json(state)
+    end
+
+    def self.to_string(location, default: "*:*:*...*:*")
+      location&.to_s || default
+    end
+
+    def add_required_child(name, range)
+      _add_required_child(name, range.begin, range.end)
+    end
+
+    def add_optional_child(name, range)
+      if range
+        _add_optional_child(name, range.begin, range.end)
+      else
+        _add_optional_no_child(name);
+      end
+    end
+
+    def each_optional_key(&block)
+      if block
+        _optional_keys.uniq.each(&block)
+      else
+        enum_for(:each_optional_key)
+      end
+    end
+
+    def each_required_key(&block)
+      if block
+        _required_keys.uniq.each(&block)
+      else
+        enum_for(:each_required_key)
+      end
+    end
+  end
+end

data/lib/rbs/locator.rb

@@ -172,16 +172,19 @@ module RBS
 
     def find_in_loc(pos, location:, array:)
       if test_loc(pos, location: location)
-        if location.is_a?(Location::WithChildren)
-          location.optional_children.each do |key, range|
-            if range === pos
-              array.unshift(key)
-              return true
+        if location.is_a?(Location)
+          location.each_optional_key do |key|
+            if loc = location[key]
+              if loc.range === pos
+                array.unshift(key)
+                return true
+              end
             end
           end
 
-          location.required_children.each do |key, range|
-            if range === pos
+          location.each_required_key do |key|
+            loc = location[key] or raise
+            if loc.range === pos
               array.unshift(key)
               return true
             end