yarp 0.6.0

data/lib/yarp/pack.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module YARP
+  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/yarp/ripper_compat.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module YARP
+  # This class is meant to provide a compatibility layer between YARP and
+  # Ripper. It functions by parsing the entire tree first and then walking it
+  # and executing each of the Ripper callbacks as it goes.
+  #
+  # This class is going to necessarily be slower than the native Ripper API. It
+  # is meant as a stopgap until developers migrate to using YARP. It is also
+  # meant as a test harness for the YARP parser.
+  class RipperCompat
+    # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+    # returns the arrays of [type, *children].
+    class SexpBuilder < RipperCompat
+      private
+
+      Ripper::PARSER_EVENTS.each do |event|
+        define_method(:"on_#{event}") do |*args|
+          [event, *args]
+        end
+      end
+
+      Ripper::SCANNER_EVENTS.each do |event|
+        define_method(:"on_#{event}") do |value|
+          [:"@#{event}", value, [lineno, column]]
+        end
+      end
+    end
+
+    # This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
+    # returns the same values as ::Ripper::SexpBuilder except with a couple of
+    # niceties that flatten linked lists into arrays.
+    class SexpBuilderPP < SexpBuilder
+      private
+
+      def _dispatch_event_new
+        []
+      end
+
+      def _dispatch_event_push(list, item)
+        list << item
+        list
+      end
+
+      Ripper::PARSER_EVENT_TABLE.each do |event, arity|
+        case event
+        when /_new\z/
+          alias :"on_#{event}" :_dispatch_event_new if arity == 0
+        when /_add\z/
+          alias :"on_#{event}" :_dispatch_event_push
+        end
+      end
+    end
+
+    attr_reader :source, :lineno, :column
+
+    def initialize(source)
+      @source = source
+      @result = nil
+      @lineno = nil
+      @column = nil
+    end
+
+    ############################################################################
+    # Public interface
+    ############################################################################
+
+    def error?
+      result.errors.any?
+    end
+
+    def parse
+      result.value.accept(self) unless error?
+    end
+
+    ############################################################################
+    # Visitor methods
+    ############################################################################
+
+    def visit(node)
+      node&.accept(self)
+    end
+
+    def visit_call_node(node)
+      if !node.opening_loc && node.arguments.arguments.length == 1
+        bounds(node.receiver.location)
+        left = visit(node.receiver)
+
+        bounds(node.arguments.arguments.first.location)
+        right = visit(node.arguments.arguments.first)
+
+        on_binary(left, source[node.message_loc.start_offset...node.message_loc.end_offset].to_sym, right)
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def visit_integer_node(node)
+      bounds(node.location)
+      on_int(source[node.location.start_offset...node.location.end_offset])
+    end
+
+    def visit_statements_node(node)
+      bounds(node.location)
+      node.body.inject(on_stmts_new) do |stmts, stmt|
+        on_stmts_add(stmts, visit(stmt))
+      end
+    end
+
+    def visit_token(node)
+      bounds(node.location)
+
+      case node.type
+      when :MINUS
+        on_op(node.value)
+      when :PLUS
+        on_op(node.value)
+      else
+        raise NotImplementedError, "Unknown token: #{node.type}"
+      end
+    end
+
+    def visit_program_node(node)
+      bounds(node.location)
+      on_program(visit(node.statements))
+    end
+
+    ############################################################################
+    # Entrypoints for subclasses
+    ############################################################################
+
+    # This is a convenience method that runs the SexpBuilder subclass parser.
+    def self.sexp_raw(source)
+      SexpBuilder.new(source).parse
+    end
+
+    # This is a convenience method that runs the SexpBuilderPP subclass parser.
+    def self.sexp(source)
+      SexpBuilderPP.new(source).parse
+    end
+
+    private
+
+    # This method is responsible for updating lineno and column information
+    # to reflect the current node.
+    #
+    # This method could be drastically improved with some caching on the start
+    # of every line, but for now it's good enough.
+    def bounds(location)
+      start_offset = location.start_offset
+
+      @lineno = source[0..start_offset].count("\n") + 1
+      @column = start_offset - (source.rindex("\n", start_offset) || 0)
+    end
+
+    def result
+      @result ||= YARP.parse(source)
+    end
+
+    def _dispatch0; end
+    def _dispatch1(_); end
+    def _dispatch2(_, _); end
+    def _dispatch3(_, _, _); end
+    def _dispatch4(_, _, _, _); end
+    def _dispatch5(_, _, _, _, _); end
+    def _dispatch7(_, _, _, _, _, _, _); end
+
+    (Ripper::SCANNER_EVENT_TABLE.merge(Ripper::PARSER_EVENT_TABLE)).each do |event, arity|
+      alias :"on_#{event}" :"_dispatch#{arity}"
+    end
+  end
+end