prism 0.13.0

data/lib/prism/node_ext.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Here we are reopening the prism module to provide methods on nodes that aren't
+# templated and are meant as convenience methods.
+module Prism
+  class FloatNode < Node
+    # Returns the value of the node as a Ruby Float.
+    def value
+      Float(slice)
+    end
+  end
+
+  class ImaginaryNode < Node
+    # Returns the value of the node as a Ruby Complex.
+    def value
+      Complex(0, numeric.value)
+    end
+  end
+
+  class IntegerNode < Node
+    # Returns the value of the node as a Ruby Integer.
+    def value
+      Integer(slice)
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    def options
+      o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
+      o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
+      o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+      o
+    end
+  end
+
+  class RationalNode < Node
+    # Returns the value of the node as a Ruby Rational.
+    def value
+      Rational(slice.chomp("r"))
+    end
+  end
+
+  class RegularExpressionNode < Node
+    # Returns a numeric value that represents the flags that were used to create
+    # the regular expression.
+    def options
+      o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
+      o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
+      o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+      o
+    end
+  end
+end

data/lib/prism/node_inspector.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Prism
+  # This object is responsible for generating the output for the inspect method
+  # implementations of child nodes.
+  class NodeInspector
+    attr_reader :prefix, :output
+
+    def initialize(prefix = "")
+      @prefix = prefix
+      @output = +""
+    end
+
+    # Appends a line to the output with the current prefix.
+    def <<(line)
+      output << "#{prefix}#{line}"
+    end
+
+    # This generates a string that is used as the header of the inspect output
+    # for any given node.
+    def header(node)
+      output = +"@ #{node.class.name.split("::").last} ("
+      output << "location: (#{node.location.start_line},#{node.location.start_column})-(#{node.location.end_line},#{node.location.end_column})"
+      output << ", newline: true" if node.newline?
+      output << ")\n"
+      output
+    end
+
+    # Generates a string that represents a list of nodes. It handles properly
+    # using the box drawing characters to make the output look nice.
+    def list(prefix, nodes)
+      output = +"(length: #{nodes.length})\n"
+      last_index = nodes.length - 1
+
+      nodes.each_with_index do |node, index|
+        pointer, preadd = (index == last_index) ? ["└── ", "    "] : ["├── ", "│   "]
+        node_prefix = "#{prefix}#{preadd}"
+        output << node.inspect(NodeInspector.new(node_prefix)).sub(node_prefix, "#{prefix}#{pointer}")
+      end
+
+      output
+    end
+
+    # Generates a string that represents a location field on a node.
+    def location(value)
+      if value
+        "(#{value.start_line},#{value.start_column})-(#{value.end_line},#{value.end_column}) = #{value.slice.inspect}"
+      else
+        "∅"
+      end
+    end
+
+    # Generates a string that represents a child node.
+    def child_node(node, append)
+      node.inspect(child_inspector(append)).delete_prefix(prefix)
+    end
+
+    # Returns a new inspector that can be used to inspect a child node.
+    def child_inspector(append)
+      NodeInspector.new("#{prefix}#{append}")
+    end
+
+    # Returns the output as a string.
+    def to_str
+      output
+    end
+  end
+end

data/lib/prism/pack.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Prism
+  module Pack
+    %i[
+      SPACE
+      COMMENT
+      INTEGER
+      UTF8
+      BER
+      FLOAT
+      STRING_SPACE_PADDED
+      STRING_NULL_PADDED
+      STRING_NULL_TERMINATED
+      STRING_MSB
+      STRING_LSB
+      STRING_HEX_HIGH
+      STRING_HEX_LOW
+      STRING_UU
+      STRING_MIME
+      STRING_BASE64
+      STRING_FIXED
+      STRING_POINTER
+      MOVE
+      BACK
+      NULL
+
+      UNSIGNED
+      SIGNED
+      SIGNED_NA
+
+      AGNOSTIC_ENDIAN
+      LITTLE_ENDIAN
+      BIG_ENDIAN
+      NATIVE_ENDIAN
+      ENDIAN_NA
+
+      SIZE_SHORT
+      SIZE_INT
+      SIZE_LONG
+      SIZE_LONG_LONG
+      SIZE_8
+      SIZE_16
+      SIZE_32
+      SIZE_64
+      SIZE_P
+      SIZE_NA
+
+      LENGTH_FIXED
+      LENGTH_MAX
+      LENGTH_RELATIVE
+      LENGTH_NA
+    ].each do |const|
+      const_set(const, const)
+    end
+
+    class Directive
+      attr_reader :version, :variant, :source, :type, :signed, :endian, :size, :length_type, :length
+
+      def initialize(version, variant, source, type, signed, endian, size, length_type, length)
+        @version = version
+        @variant = variant
+        @source = source
+        @type = type
+        @signed = signed
+        @endian = endian
+        @size = size
+        @length_type = length_type
+        @length = length
+      end
+
+      ENDIAN_DESCRIPTIONS = {
+        AGNOSTIC_ENDIAN: 'agnostic',
+        LITTLE_ENDIAN: 'little-endian (VAX)',
+        BIG_ENDIAN: 'big-endian (network)',
+        NATIVE_ENDIAN: 'native-endian',
+        ENDIAN_NA: 'n/a'
+      }
+
+      SIGNED_DESCRIPTIONS = {
+        UNSIGNED: 'unsigned',
+        SIGNED: 'signed',
+        SIGNED_NA: 'n/a'
+      }
+
+      SIZE_DESCRIPTIONS = {
+        SIZE_SHORT: 'short',
+        SIZE_INT: 'int-width',
+        SIZE_LONG: 'long',
+        SIZE_LONG_LONG: 'long long',
+        SIZE_8: '8-bit',
+        SIZE_16: '16-bit',
+        SIZE_32: '32-bit',
+        SIZE_64: '64-bit',
+        SIZE_P: 'pointer-width'
+      }
+
+      def describe
+        case type
+        when SPACE
+          'whitespace'
+        when COMMENT
+          'comment'
+        when INTEGER
+          if size == SIZE_8
+            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} integer"
+          else
+            base = "#{SIGNED_DESCRIPTIONS[signed]} #{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} integer"
+          end
+          case length_type
+          when LENGTH_FIXED
+            if length > 1
+              base + ", x#{length}"
+            else
+              base
+            end
+          when LENGTH_MAX
+            base + ', as many as possible'
+          end
+        when UTF8
+          'UTF-8 character'
+        when BER
+          'BER-compressed integer'
+        when FLOAT
+          "#{SIZE_DESCRIPTIONS[size]} #{ENDIAN_DESCRIPTIONS[endian]} float"
+        when STRING_SPACE_PADDED
+          'arbitrary binary string (space padded)'
+        when STRING_NULL_PADDED
+          'arbitrary binary string (null padded, count is width)'
+        when STRING_NULL_TERMINATED
+          'arbitrary binary string (null padded, count is width), except that null is added with *'
+        when STRING_MSB
+          'bit string (MSB first)'
+        when STRING_LSB
+          'bit string (LSB first)'
+        when STRING_HEX_HIGH
+          'hex string (high nibble first)'
+        when STRING_HEX_LOW
+          'hex string (low nibble first)'
+        when STRING_UU
+          'UU-encoded string'
+        when STRING_MIME
+          'quoted printable, MIME encoding'
+        when STRING_BASE64
+          'base64 encoded string'
+        when STRING_FIXED
+          'pointer to a structure (fixed-length string)'
+        when STRING_POINTER
+          'pointer to a null-terminated string'
+        when MOVE
+          'move to absolute position'
+        when BACK
+          'back up a byte'
+        when NULL
+          'null byte'
+        else
+          raise
+        end
+      end
+    end
+
+    class Format
+      attr_reader :directives, :encoding
+
+      def initialize(directives, encoding)
+        @directives = directives
+        @encoding = encoding
+      end
+
+      def describe
+        source_width = directives.map { |d| d.source.inspect.length }.max
+        directive_lines = directives.map do |directive|
+          if directive.type == SPACE
+            source = directive.source.inspect
+          else
+            source = directive.source
+          end
+          "  #{source.ljust(source_width)}  #{directive.describe}"
+        end
+
+        (['Directives:'] + directive_lines + ['Encoding:', "  #{encoding}"]).join("\n")
+      end
+    end
+  end
+end

data/lib/prism/parse_result/comments.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Prism
+  class ParseResult
+    # When we've parsed the source, we have both the syntax tree and the list of
+    # comments that we found in the source. This class is responsible for
+    # walking the tree and finding the nearest location to attach each comment.
+    #
+    # It does this by first finding the nearest locations to each comment.
+    # Locations can either come from nodes directly or from location fields on
+    # nodes. For example, a `ClassNode` has an overall location encompassing the
+    # entire class, but it also has a location for the `class` keyword.
+    #
+    # Once the nearest locations are found, it determines which one to attach
+    # to. If it's a trailing comment (a comment on the same line as other source
+    # code), it will favor attaching to the nearest location that occurs before
+    # the comment. Otherwise it will favor attaching to the nearest location
+    # that is after the comment.
+    class Comments
+      # A target for attaching comments that is based on a specific node's
+      # location.
+      class NodeTarget
+        attr_reader :node
+
+        def initialize(node)
+          @node = node
+        end
+
+        def start_offset
+          node.location.start_offset
+        end
+
+        def end_offset
+          node.location.end_offset
+        end
+
+        def encloses?(comment)
+          start_offset <= comment.location.start_offset &&
+            comment.location.end_offset <= end_offset
+        end
+
+        def <<(comment)
+          node.location.comments << comment
+        end
+      end
+
+      # A target for attaching comments that is based on a location field on a
+      # node. For example, the `end` token of a ClassNode.
+      class LocationTarget
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def start_offset
+          location.start_offset
+        end
+
+        def end_offset
+          location.end_offset
+        end
+
+        def encloses?(comment)
+          false
+        end
+
+        def <<(comment)
+          location.comments << comment
+        end
+      end
+
+      attr_reader :parse_result
+
+      def initialize(parse_result)
+        @parse_result = parse_result
+      end
+
+      def attach!
+        parse_result.comments.each do |comment|
+          preceding, enclosing, following = nearest_targets(parse_result.value, comment)
+          target =
+            if comment.trailing?
+              preceding || following || enclosing || NodeTarget.new(parse_result.value)
+            else
+              # If a comment exists on its own line, prefer a leading comment.
+              following || preceding || enclosing || NodeTarget.new(parse_result.value)
+            end
+
+          target << comment
+        end
+      end
+
+      private
+
+      # Responsible for finding the nearest targets to the given comment within
+      # the context of the given encapsulating node.
+      def nearest_targets(node, comment)
+        comment_start = comment.location.start_offset
+        comment_end = comment.location.end_offset
+
+        targets = []
+        node.comment_targets.map do |value|
+          case value
+          when StatementsNode
+            targets.concat(value.body.map { |node| NodeTarget.new(node) })
+          when Node
+            targets << NodeTarget.new(value)
+          when Location
+            targets << LocationTarget.new(value)
+          end
+        end
+
+        targets.sort_by!(&:start_offset)
+        preceding = nil
+        following = nil
+
+        left = 0
+        right = targets.length
+
+        # This is a custom binary search that finds the nearest nodes to the
+        # given comment. When it finds a node that completely encapsulates the
+        # comment, it recurses downward into the tree.
+        while left < right
+          middle = (left + right) / 2
+          target = targets[middle]
+
+          target_start = target.start_offset
+          target_end = target.end_offset
+
+          if target.encloses?(comment)
+            # The comment is completely contained by this target. Abandon the
+            # binary search at this level.
+            return nearest_targets(target.node, comment)
+          end
+
+          if target_end <= comment_start
+            # This target falls completely before the comment. Because we will
+            # never consider this target or any targets before it again, this
+            # target must be the closest preceding target we have encountered so
+            # far.
+            preceding = target
+            left = middle + 1
+            next
+          end
+
+          if comment_end <= target_start
+            # This target falls completely after the comment. Because we will
+            # never consider this target or any targets after it again, this
+            # target must be the closest following target we have encountered so
+            # far.
+            following = target
+            right = middle
+            next
+          end
+
+          # This should only happen if there is a bug in this parser.
+          raise "Comment location overlaps with a target location"
+        end
+
+        [preceding, NodeTarget.new(node), following]
+      end
+    end
+
+    private_constant :Comments
+
+    # Attach the list of comments to their respective locations in the tree.
+    def attach_comments!
+      Comments.new(self).attach!
+    end
+  end
+end

data/lib/prism/parse_result/newlines.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Prism
+  class ParseResult
+    # The :line tracepoint event gets fired whenever the Ruby VM encounters an
+    # expression on a new line. The types of expressions that can trigger this
+    # event are:
+    #
+    # * if statements
+    # * unless statements
+    # * nodes that are children of statements lists
+    #
+    # In order to keep track of the newlines, we have a list of offsets that
+    # come back from the parser. We assign these offsets to the first nodes that
+    # we find in the tree that are on those lines.
+    #
+    # Note that the logic in this file should be kept in sync with the Java
+    # MarkNewlinesVisitor, since that visitor is responsible for marking the
+    # newlines for JRuby/TruffleRuby.
+    class Newlines < Visitor
+      def initialize(newline_marked)
+        @newline_marked = newline_marked
+      end
+
+      def visit_block_node(node)
+        old_newline_marked = @newline_marked
+        @newline_marked = Array.new(old_newline_marked.size, false)
+
+        begin
+          super(node)
+        ensure
+          @newline_marked = old_newline_marked
+        end
+      end
+
+      alias_method :visit_lambda_node, :visit_block_node
+
+      def visit_if_node(node)
+        node.set_newline_flag(@newline_marked)
+        super(node)
+      end
+
+      alias_method :visit_unless_node, :visit_if_node
+
+      def visit_statements_node(node)
+        node.body.each do |child|
+          child.set_newline_flag(@newline_marked)
+        end
+        super(node)
+      end
+    end
+
+    private_constant :Newlines
+
+    # Walk the tree and mark nodes that are on a new line.
+    def mark_newlines!
+      value.accept(Newlines.new(Array.new(1 + source.offsets.size, false)))
+    end
+  end
+end