rbs-inline 0.3.0 → 0.5.0

data/lib/rbs/inline/ast/comment_lines.rb

@@ -1,35 +1,49 @@
+# rbs_inline: enabled
+
 module RBS
   module Inline
     module AST
+      # CommentLines represents consecutive comments, providing a mapping from locations in `#string` to a pair of a comment and its offset
+      #
+      # The comments construct one String.
+      #
+      # ```ruby
+      # # Hello       <-- Comment1
+      # # World       <-- Comment2
+      # ```
+      #
+      # We want to get a String of comment1 and comment2, `"Hello\nWorld".
+      # And want to translate a location in the string into the location in comment1 and comment2.
+      #
       class CommentLines
-        attr_reader :comments
-
-        def initialize(comments)
-          offsets = comments.map do |comment|
-            comment.location.slice.index(/[^#\s]/) || 1
-          end
-          first_offset = offsets[0]
+        attr_reader :comments #: Array[Prism::Comment]
 
-          @comments = comments.map.with_index do |comment, index|
-            offset = offsets[index]
-            offset = first_offset if offset > first_offset
+        # @rbs comments: Array[Prism::Comment]
+        def initialize(comments) #: void
+          @comments = comments
+        end
 
-            [comment, offset]
-          end
+        def lines #: Array[String]
+          comments.map {|comment| comment.location.slice }
         end
 
-        def string
-          comments.map {|comment, offset| comment.location.slice[offset..] }.join("\n")
+        def string #: String
+          comments.map {|comment| comment.location.slice[1..] || "" }.join("\n")
         end
 
+        # Translates the cursor index of `#string` into the cursor index of a specific comment object
+        #
+        # @rbs index: Integer
+        # @rbs return: [Prism::Comment, Integer]?
         def comment_location(index)
-          comments.each do |comment, offset|
+          comments.each do |comment|
             comment_length = comment.location.length
 
-            if index + offset <= comment_length
-              return [comment, index + offset]
+            if index + 1 <= comment_length
+              return [comment, index + 1]
             else
-              index = index - comment_length + offset - 1
+              index -= comment_length - 1
+              index -= 1 # newline
               return if index < 0
             end
           end

data/lib/rbs/inline/ast/declarations.rb

@@ -6,7 +6,7 @@ module RBS
       module Declarations
         module ConstantUtil
           # @rbs node: Prism::Node
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def type_name(node)
             case node
             when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -15,19 +15,19 @@ module RBS
           end
         end
 
-        # @rbs! type t = ClassDecl | ModuleDecl | ConstantDecl
-
         # @rbs!
+        #   type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl
+        #
         #  interface _WithComments
         #    def comments: () -> AnnotationParser::ParsingResult?
         #  end
 
         # @rbs module-self _WithComments
         module Generics
-          # @rbs returns Array[RBS::AST::TypeParam]
+          # @rbs return: Array[RBS::AST::TypeParam]
           def type_params
             if comments = comments()
-              comments.annotations.filter_map do |annotation|
+              comments.each_annotation.filter_map do |annotation|
                 if annotation.is_a?(Annotations::Generic)
                   annotation.type_param
                 end
@@ -44,26 +44,26 @@ module RBS
         # @rbs generic NODE < Prism::Node
         class ModuleOrClass < Base
           # The node that represents the declaration
-          attr_reader :node #:: NODE
+          attr_reader :node #: NODE
 
           # Leading comment
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
+          attr_reader :comments #: AnnotationParser::ParsingResult?
 
           # Members included in the declaration
-          attr_reader :members #:: Array[Members::t | t]
+          attr_reader :members #: Array[Members::t | t]
 
           # @rbs node: NODE
           # @rbs comments: AnnotationParser::ParsingResult?
-          def initialize(node, comments) #:: void
+          def initialize(node, comments) #: void
             @node = node
             @comments = comments
             @members = []
           end
 
           # Type parameters for the declaration
-          def type_params #:: Array[RBS::AST::TypeParam]
+          def type_params #: Array[RBS::AST::TypeParam]
             if comments = comments()
-              comments.annotations.filter_map do |annotation|
+              comments.each_annotation.filter_map do |annotation|
                 if annotation.is_a?(Annotations::Generic)
                   annotation.type_param
                 end
@@ -73,7 +73,7 @@ module RBS
             end
           end
 
-          def start_line #:: Integer
+          def start_line #: Integer
             node.location.start_line
           end
         end
@@ -82,12 +82,12 @@ module RBS
           include ConstantUtil
 
           # Type application for super class
-          attr_reader :super_app #:: Annotations::Application?
+          attr_reader :super_app #: Annotations::Application?
 
           # @rbs node: Prism::ClassNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs super_app: Annotations::Application?
-          # @rbs returns void
+          # @rbs return: void
           def initialize(node, comments, super_app)
             super(node, comments)
 
@@ -95,14 +95,14 @@ module RBS
           end
 
           # @rbs %a{pure}
-          def class_name #:: TypeName?
+          def class_name #: TypeName?
             type_name(node.constant_path)
           end
 
           # @rbs %a{pure}
-          def super_class #:: RBS::AST::Declarations::Class::Super?
+          def super_class #: RBS::AST::Declarations::Class::Super?
             if comments
-              if inherits = comments.annotations.find {|a| a.is_a?(Annotations::Inherits) } #: Annotations::Inherits?
+              if inherits = comments.each_annotation.find {|a| a.is_a?(Annotations::Inherits) } #: Annotations::Inherits?
                 super_name = inherits.super_name
                 super_args = inherits.args
 
@@ -141,14 +141,14 @@ module RBS
           include ConstantUtil
 
           # @rbs %a{pure}
-          def module_name #:: TypeName?
+          def module_name #: TypeName?
             type_name(node.constant_path)
           end
 
           # @rbs %a{pure}
-          def module_selfs #:: Array[Annotations::ModuleSelf]
+          def module_selfs #: Array[Annotations::ModuleSelf]
             if comments
-              comments.annotations.filter_map do |ann|
+              comments.each_annotation.filter_map do |ann|
                 if ann.is_a?(AST::Annotations::ModuleSelf)
                   ann
                 end
@@ -162,21 +162,21 @@ module RBS
         class ConstantDecl < Base
           include ConstantUtil
 
-          attr_reader :node #:: Prism::ConstantWriteNode
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
-          attr_reader :assertion #:: Annotations::Assertion?
+          attr_reader :node #: Prism::ConstantWriteNode
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+          attr_reader :assertion #: Annotations::TypeAssertion?
 
           # @rbs node: Prism::ConstantWriteNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          # @rbs assertion: Annotations::Assertion?
-          def initialize(node, comments, assertion)
+          # @rbs assertion: Annotations::TypeAssertion?
+          def initialize(node, comments, assertion) #: void
             @node = node
             @comments = comments
             @assertion = assertion
           end
 
           # @rbs %a{pure}
-          # @rbs returns Types::t
+          # @rbs return: Types::t
           def type
             if assertion
               case assertion.type
@@ -218,15 +218,54 @@ module RBS
           end
 
           # @rbs %a{pure}
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def constant_name
             TypeName.new(name: node.name, namespace: Namespace.empty)
           end
 
-          def start_line #:: Integer
+          def start_line #: Integer
             node.location.start_line
           end
         end
+
+        class SingletonClassDecl < ModuleOrClass #[Prism::SingletonClassNode]
+        end
+
+        class BlockDecl < Base
+          attr_reader :node #: Prism::BlockNode
+
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+
+          # Members included in the declaration
+          attr_reader :members #: Array[Members::t | t]
+
+          # @rbs (Prism::BlockNode, AnnotationParser::ParsingResult?) -> void
+          def initialize(node, comments)
+            @node = node
+            @members = []
+            @comments = comments
+          end
+
+          def start_line #: Integer
+            node.location.start_line
+          end
+
+          def module_class_annotation #: Annotations::ModuleDecl | Annotations::ClassDecl | nil
+            if comments
+              comments.each_annotation.each do |annotation|
+                if annotation.is_a?(Annotations::ModuleDecl)
+                  return annotation
+                end
+
+                if annotation.is_a?(Annotations::ClassDecl)
+                  return annotation
+                end
+              end
+
+              nil
+            end
+          end
+        end
       end
     end
   end