sirop 0.3 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a44761c6907c2bd7358e0b7d6c4079b8582949121ff32161b508a0950d0032c
-  data.tar.gz: 99cf621e80d420ec1a4245e8fd9efdbb06633614982d804d45f545f0a1966a0b
+  metadata.gz: eee92f9d96e1938e770c3c2eb445e43a68c67920e3e885a8016f2150ce429ec5
+  data.tar.gz: 5a7ebbb732eae90b4b3f35f54728f118684eab3f32575ce6000795310a6ca541
 SHA512:
-  metadata.gz: de992959d865f0ace64d1be7b9c0149a10d193f54e2bfa0e9b20dcd2fe70f7bf4fe3ec5984c29a75cf89bc70dc385d29747ba372174bfe4286654b3543e0f946
-  data.tar.gz: '00393520ab9df84615c35a104411d4aad118c07ac4d4212debbf21df536f90883dd924e31e4d9064d4ce7344fa425716c292d4f9fbe3e1fb3b675ccea054fe95'
+  metadata.gz: bda8d3c698363b564d14077994cb96ccaabbf1408bab88e37492d88ec30d251926af93340ac376174b7f7c18f27408b9ab942bc68a16d3fdc27b32755d9209aa
+  data.tar.gz: 2a84dd4f5586e18f2a5b2eb87759285b20b422e484e6d4afebd58fd10a707a4baa962713b296c9b36a45b8a219b10552ceae3e29e8882e36c26022f9dc144371

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 2025-01-09 0.5
+
+- Add after_body hook for lambdas
+
+# 2024-04-29 0.4
+
+- Improve sourcifier to support all Ruby syntax, based on Prism test fixtures
+- Update Prism
+
 # 2024-04-19 0.3
 
 - Add support for injecting (prefixed) parameters to a lambda node

data/lib/sirop/prism_ext.rb

@@ -18,6 +18,8 @@ class Prism::BlockParametersNode
 end
 
 class Prism::LambdaNode
+  attr_reader :after_body_proc
+
   # @param params [String] injected parameters
   # @return [void]
   def inject_parameters(params)
@@ -31,4 +33,8 @@ class Prism::LambdaNode
       instance_variable_set(:@parameters, Sirop::Injection.new("(#{params})"))
     end
   end
+
+  def after_body(&b)
+    @after_body_proc = b
+  end
 end

data/lib/sirop/sourcifier.rb

@@ -5,6 +5,90 @@ require 'prism'
 module Sirop
   # 
   class Sourcifier < Prism::BasicVisitor
+    VISIT_PLANS = {
+      alias_global_variable:      [:keyword_loc, :new_name, :old_name],
+      alias_method:               [:keyword_loc, :new_name, :old_name],
+      and:                        [:left, :operator_loc, :right],
+      assoc:                      [:key, :operator_loc, :value],
+      assoc_splat:                [:operator_loc, :value],
+      back_reference_read:        :emit_verbatim,
+      block:                      [:opening_loc, :parameters, :body, :closing_loc],
+      block_argument:             [:operator_loc, :expression],
+      block_local_variable:       :emit_verbatim,
+      block_parameter:            [:operator_loc, :name_loc],
+      break:                      [:keyword_loc, :arguments],
+      capture_pattern:            [:value, :operator_loc, :target],
+      class_variable_read:        :emit_verbatim,
+      class_variable_target:      :emit_verbatim,
+      class_variable_write:       [:name_loc, :operator_loc, :value],
+      constant_path:              [:parent, :delimiter_loc, :child],
+      constant_path_write:        [:target, :operator_loc, :value],
+      constant_read:              :emit_verbatim,
+      constant_write:             [:name_loc, :operator_loc, :value],
+      defined:                    [:keyword_loc, :lparen_loc, :value, :rparen_loc],
+      embedded_statements:        [:opening_loc, :statements, :closing_loc],
+      embedded_variable:          [:operator_loc, :variable],
+      false:                      :emit_verbatim,
+      flip_flop:                  [:left, :operator_loc, :right],
+      float:                      :emit_verbatim,
+      forwarding_arguments:       :emit_verbatim,
+      forwarding_parameter:       :emit_verbatim,
+      forwarding_super:           :emit_verbatim,
+      global_variable_read:       :emit_verbatim,
+      global_variable_target:     :emit_verbatim,
+      global_variable_write:      [:name_loc, :operator_loc, :value],
+      imaginary:                  :emit_verbatim,
+      implicit:                   :emit_nothing,
+      implicit_rest:              :emit_nothing,
+      in:                         [:in_loc, :pattern, :then_loc],
+      index_target:               [:receiver, :opening_loc, :arguments, :closing_loc],
+      instance_variable_read:     :emit_verbatim,
+      instance_variable_target:   :emit_verbatim,
+      instance_variable_write:    [:name_loc, :operator_loc, :value],
+      integer:                    :emit_verbatim,
+      keyword_rest_parameter:     [:operator_loc, :name_loc],
+      keyword_parameter:          :emit_verbatim,
+      local_variable_and_write:   [:name_loc, :operator_loc, :value],
+      local_variable_operator_write: [:name_loc, :operator_loc, :value],
+      local_variable_or_write:    [:name_loc, :operator_loc, :value],
+      local_variable_read:        :emit_verbatim,
+      local_variable_target:      :emit_verbatim,
+      local_variable_write:       [:name_loc, :operator_loc, :value],
+      match_predicate:            [:value, :operator_loc, :pattern],
+      match_required:             [:value, :operator_loc, :pattern],
+      match_write:                [:call],
+      next:                       [:keyword_loc, :arguments],
+      nil:                        :emit_verbatim,
+      no_keywords_parameter:      :emit_verbatim,
+      numbered_parameters:        :emit_nothing,
+      optional_parameter:         [:name_loc, :operator_loc, :value],
+      optional_keyword_parameter: [:name_loc, :value],
+      or:                         [:left, :operator_loc, :right],
+      parentheses:                [:opening_loc, :body, :closing_loc],
+      pinned_expression:          [:operator_loc, :lparen_loc, :expression, :rparen_loc],
+      pinned_variable:            [:operator_loc, :variable],
+      range:                      [:left, :operator_loc, :right],
+      rational:                   :emit_verbatim,
+      redo:                       :emit_verbatim,
+      regular_expression:         :emit_verbatim,
+      required_parameter:         :emit_verbatim,
+      required_keyword_parameter: :emit_verbatim,
+      rescue_modifier:            [:expression, :keyword_loc, :rescue_expression],
+      rest_parameter:             [:operator_loc, :name_loc],
+      retry:                      :emit_verbatim,
+      return:                     [:keyword_loc, :arguments],
+      self:                       :emit_verbatim,
+      source_encoding:            :emit_verbatim,
+      source_file:                :emit_verbatim,
+      source_line:                :emit_verbatim,
+      splat:                      [:operator_loc, :expression],
+      string:                     [:opening_loc, :content_loc, :closing_loc],
+      symbol:                     :emit_verbatim,
+      true:                       :emit_verbatim,
+      x_string:                   :emit_verbatim,
+      yield:                      [:keyword_loc, :lparen_loc, :arguments, :rparen_loc]
+    }
+
     attr_reader :buffer
 
     def initialize
@@ -52,20 +136,34 @@ module Sirop
       @last_loc_end = loc_end(loc)
     end
 
-    def emit_code(loc, semicolon: false)
+    def emit_code(loc, semicolon: false, chomp: false)
       return if !loc
 
+      if @last_loc
+        loc_loc = loc.is_a?(Prism::Node) ? loc.location : loc
+        return if loc_loc.slice == @last_loc.slice && loc_loc.start_line == @last_loc.start_line && 
+          loc_loc.start_column == @last_loc.start_column
+      end
+
+      semicolon ||= @semicolon
+      @semicolon = false
       emit_semicolon(loc) if semicolon
       return visit(loc) if loc.is_a?(Prism::Node)
 
       adjust_whitespace(loc)
-      emit(loc.slice)
+      str = loc.slice
+      str = str.chomp if chomp
+      emit(str)
     end
   
     def emit_verbatim(node)
       emit_code(node.location)
     end
 
+    def emit_nothing(node)
+      # emit nothing
+    end  
+
     def emit_str(str)
       emit(str)
       @last_loc_end[1] += str.size
@@ -77,7 +175,11 @@ module Sirop
 
     def emit_semicolon(loc)
       loc = loc.location if loc.is_a?(Prism::Node)
-      emit_str(';') if loc.start_line == @last_loc.end_line
+      if @last_loc && loc.start_line == @last_loc.end_line
+        if @buffer[-1] != ';' && loc.start_column > @last_loc_end[1]
+          emit_str(';')
+        end
+      end
     end
 
     def method_missing(sym, node, *args)
@@ -87,44 +189,6 @@ module Sirop
       visit_child_nodes(node)
     end
 
-    VISIT_PLANS = {
-      and:                        [:left, :operator_loc, :right],
-      assoc:                      :visit_child_nodes,
-      assoc_splat:                [:operator_loc, :value],
-      block:                      [:opening_loc, :parameters, :body, :closing_loc],
-      block_argument:             [:operator_loc, :expression],
-      block_parameter:            [:operator_loc, :name_loc],
-      block_parameters:           [:opening_loc, :injected_parameters, :parameters, :closing_loc],
-      break:                      [:keyword_loc, :arguments],
-      constant_path:              [:parent, :delimiter_loc, :child],
-      constant_read:              :emit_verbatim,
-      else:                       [:else_keyword_loc, :statements],
-      embedded_statements:        [:opening_loc, :statements, :closing_loc],
-      false:                      :emit_verbatim,
-      integer:                    :emit_verbatim,
-      keyword_rest_parameter:     [:operator_loc, :name_loc],
-      keyword_parameter:          :emit_verbatim,
-      lambda:                     [:operator_loc, :parameters, :opening_loc, :body,
-                                   :closing_loc],
-      local_variable_read:        :emit_verbatim,
-      local_variable_write:       [:name_loc, :operator_loc, :value],
-      next:                       [:keyword_loc, :arguments],
-      nil:                        :emit_verbatim,
-      optional_parameter:         [:name_loc, :operator_loc, :value],
-      optional_keyword_parameter: [:name_loc, :value],
-      or:                         [:left, :operator_loc, :right],
-      parentheses:                [:opening_loc, :body, :closing_loc],
-      required_parameter:         :emit_verbatim,
-      required_keyword_parameter: :emit_verbatim,
-      rest_parameter:             [:operator_loc, :name_loc],
-      splat:                      [:operator_loc, :expression],
-      statements:                 :visit_child_nodes,
-      string:                     :emit_verbatim,
-      symbol:                     :emit_verbatim,
-      true:                       :emit_verbatim,
-      yield:                      [:keyword_loc, :lparen_loc, :arguments, :rparen_loc],
-    }
-
     VISIT_PLANS.each do |key, plan|
       sym = :"visit_#{key}_node"
       define_method(sym) { |n| visit_plan(plan, n) }
@@ -148,7 +212,7 @@ module Sirop
 
     def visit_comma_separated_nodes(list, comma = false)
       if list
-        list.each_with_index do |child, idx|
+        list.each do |child|
           emit_comma if comma
           emit_code(child)
           comma = true
@@ -157,6 +221,14 @@ module Sirop
       comma
     end
 
+    def visit_space_separated_nodes(list)
+      if list
+        list.each do |child|
+          emit_code(child)
+        end
+      end
+    end
+
     def visit_parameters_node(node)
       comma = false
       # injected_prefix is a custom attribute added by Sirop to the
@@ -171,13 +243,18 @@ module Sirop
       end
       comma = visit_comma_separated_nodes(node.requireds, comma)
       comma = visit_comma_separated_nodes(node.optionals, comma)
-      comma = visit_comma_separated_nodes(node.posts, comma)
-      comma = visit_comma_separated_nodes(node.keywords, comma)
       if node.rest
         emit_comma if comma
-        comma = true
         emit_code(node.rest)
+        comma = true
       end
+      comma = visit_comma_separated_nodes(node.posts, comma)
+      comma = visit_comma_separated_nodes(node.keywords, comma)
+      # if node.rest
+      #   emit_comma if comma
+      #   comma = true
+      #   emit_code(node.rest)
+      # end
       if node.keyword_rest
         emit_comma if comma
         comma = true
@@ -190,8 +267,8 @@ module Sirop
       end
     end
 
-    def visit_arguments_node(node)
-      visit_comma_separated_nodes(node.arguments)
+    def visit_arguments_node(node, subscript = 0..-1)
+      visit_comma_separated_nodes(node.arguments[subscript])
     end
   
     def visit_keyword_hash_node(node)
@@ -208,9 +285,9 @@ module Sirop
       emit_code(node.if_keyword_loc)
       emit_code(node.predicate)
       emit_code(node.then_keyword_loc)
-      emit_code(node.statements)
+      emit_code(node.statements, semicolon: true)
       emit_code(node.consequent) if node.consequent
-      emit_code(node.end_keyword_loc) if node.if_keyword_loc.slice == 'if'
+      emit_code(node.end_keyword_loc, semicolon: true) if node.if_keyword_loc.slice == 'if'
     end
 
     def visit_if_node_ternary(node)
@@ -226,18 +303,38 @@ module Sirop
       emit_code(node.predicate)
     end
 
+    def visit_unless_node(node)
+      if !node.end_keyword_loc
+        return visit_unless_node_guard(node)
+      end
+
+      emit_code(node.keyword_loc)
+      emit_code(node.predicate)
+      emit_code(node.then_keyword_loc)
+      @semicolon = true
+      emit_code(node.statements)
+      emit_code(node.consequent) if node.consequent
+      emit_code(node.end_keyword_loc, semicolon: true) if node.keyword_loc.slice == 'unless'
+    end
+
+    def visit_unless_node_guard(node)
+      emit_code(node.statements)        
+      emit_code(node.keyword_loc)
+      emit_code(node.predicate)
+    end
+
     def visit_case_node(node)
       emit_code(node.case_keyword_loc)
       emit_code(node.predicate)
-      node.conditions.each { |c| emit_code(c) }
-      emit_code(node.consequent)
-      emit_code(node.end_keyword_loc)
+      node.conditions.each { |c| emit_code(c, semicolon: true) }
+      emit_code(node.consequent, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
     end
 
     def visit_when_node(node)
       emit_code(node.keyword_loc)
       visit_comma_separated_nodes(node.conditions)
-      emit_code(node.statements)
+      emit_code(node.statements, semicolon: true)
     end
 
     def visit_interpolated_symbol_node(node)
@@ -248,36 +345,49 @@ module Sirop
     alias_method :visit_interpolated_string_node, :visit_interpolated_symbol_node
 
     def visit_def_node(node)
-      emit_code(node.def_keyword_loc)
+      emit_code(node.def_keyword_loc, semicolon: true)
+      emit_code(node.receiver)
+      emit_code(node.operator_loc)
       emit_code(node.name_loc)
-      last_loc = node.name_loc
 
+      emit_code(node.lparen_loc)
       if node.parameters
-        emit_str('(')
         emit_code(node.parameters)
-        emit_str(')')
-        last_loc = node.parameters.location
       end
-
-      emit_code(node.body, semicolon: true)
+      emit_code(node.rparen_loc)
+      emit_code(node.equal_loc)
+      emit_code(node.body, semicolon: !node.equal_loc)
       emit_code(node.end_keyword_loc, semicolon: true)
+      @semicolon = true
     end
 
     def visit_call_node(node)
-      if node.receiver && !node.call_operator_loc && !node.arguments
+      if node.receiver && !node.call_operator_loc && !node.arguments && node.name != :[]
         return visit_call_node_unary_op(node)
       end
 
+      if node.receiver && !node.call_operator_loc && node.name == :!
+        return visit_call_node_unary_op(node)
+      end
+
+      if node.attribute_write?
+        return visit_call_node_attribute_write(node)
+      end
+
       block = node.block
 
       emit_code(node.receiver)
       emit_code(node.call_operator_loc)
-      emit_code(node.message_loc)
+      if (ml = node.message_loc)
+        ol = node.opening_loc
+        emit_message_loc = !ol || (ol.start_line != ml.start_line) || (ol.start_column != ml.start_column)
+        emit_code(node.message_loc) if emit_message_loc
+      end
       emit_code(node.opening_loc)
       emit_code(node.arguments)
       
       if block.is_a?(Prism::BlockArgumentNode)
-        emit_comma if node.arguments&.arguments.size > 0
+        emit_comma if node.arguments && node.arguments.arguments.size > 0
         emit_code(block)
         block = nil
       end
@@ -287,7 +397,33 @@ module Sirop
 
     def visit_call_node_unary_op(node)
       emit_code(node.message_loc)
+      emit_code(node.opening_loc)
+      emit_code(node.receiver)
+      emit_code(node.closing_loc)
+    end
+
+    def visit_call_node_attribute_write(node)
       emit_code(node.receiver)
+      if node.call_operator_loc
+        emit_code(node.call_operator_loc)
+        emit_code(node.message_loc)
+      end
+      emit_code(node.opening_loc)
+      comma = visit_arguments_node(node.arguments, 0..-2)
+      if node.block
+        emit_comma if comma
+        emit_code(node.block)
+      end
+      emit_code(node.closing_loc)
+      emit_str(" = ")
+      emit_code(node.arguments.arguments[-1])
+      return
+    end
+
+    def visit_call_target_node(node)
+      emit_code(node.receiver)
+      emit_code(node.call_operator_loc)
+      emit_code(node.message_loc)
     end
 
     def visit_while_node(node)
@@ -304,5 +440,242 @@ module Sirop
       emit_code(node.keyword_loc)
       emit_code(node.predicate)
     end
+
+    def visit_until_node(node)
+      return visit_until_node_guard(node) if !node.closing_loc
+
+      emit_code(node.keyword_loc)
+      emit_code(node.predicate)
+      emit_code(node.statements, semicolon: true)
+      emit_code(node.closing_loc, semicolon: true)
+    end
+
+    def visit_until_node_guard(node)
+      emit_code(node.statements)
+      emit_code(node.keyword_loc)
+      emit_code(node.predicate)
+    end
+
+    def visit_hash_node(node)
+      emit_code(node.opening_loc)
+      visit_comma_separated_nodes(node.elements)
+      emit_code(node.closing_loc)
+    end
+  
+    def visit_array_node(node)
+      emit_code(node.opening_loc)
+      if node.opening_loc && node.opening_loc.slice =~ /^%/
+        visit_space_separated_nodes(node.elements)
+      else
+        visit_comma_separated_nodes(node.elements)
+      end
+      emit_code(node.closing_loc)
+    end
+
+    def visit_multi_write_node(node)
+      emit_code(node.lparen_loc)
+      comma = visit_comma_separated_nodes(node.lefts)
+      if node.rest
+        emit_comma if comma
+        emit_code(node.rest)
+        comma = true
+      end
+      visit_comma_separated_nodes(node.rights, comma)
+      emit_code(node.rparen_loc)
+      emit_code(node.operator_loc)
+      emit_code(node.value)
+    end
+
+    def visit_rescue_node(node)
+      emit_code(node.keyword_loc, semicolon: true)
+      visit_comma_separated_nodes(node.exceptions)
+      emit_code(node.operator_loc)
+      emit_code(node.reference)
+      emit_code(node.statements, semicolon: true)
+      emit_code(node.consequent)
+    end
+
+    def visit_begin_node(node)
+      emit_code(node.begin_keyword_loc) #, semicolon: true)
+      emit_code(node.statements, semicolon: true)
+      emit_code(node.rescue_clause)
+      emit_code(node.else_clause)
+      emit_code(node.ensure_clause)
+      emit_code(node.end_keyword_loc, semicolon: true) if node.begin_keyword_loc
+    end
+
+    def visit_index_operator_write_node(node)
+      emit_code(node.receiver)
+      emit_code(node.opening_loc)
+      emit_code(node.arguments)
+      if node.block
+        if !node.arguments.arguments.empty?
+          emit_comma
+        end
+        emit_code(node.block)
+      end
+      emit_code(node.closing_loc)
+      emit_code(node.operator_loc)
+      emit_code(node.value)
+    end
+    alias_method :visit_index_and_write_node, :visit_index_operator_write_node
+    alias_method :visit_index_or_write_node, :visit_index_operator_write_node
+
+    def visit_ensure_node(node)
+      emit_code(node.ensure_keyword_loc, semicolon: true)
+      emit_code(node.statements, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
+    end
+
+    def visit_else_node(node)
+      emit_code(node.else_keyword_loc, semicolon: node.else_keyword_loc.slice == 'else')
+      emit_code(node.statements, semicolon: node.else_keyword_loc.slice == 'else')
+    end
+
+    def visit_case_match_node(node)
+      emit_code(node.case_keyword_loc)
+      emit_code(node.predicate)
+      @semicolon = true
+      visit_comma_separated_nodes(node.conditions)
+      emit_code(node.end_keyword_loc)
+    end
+
+    def visit_class_node(node)
+      emit_code(node.class_keyword_loc)
+      emit_code(node.constant_path)
+      emit_code(node.inheritance_operator_loc)
+      emit_code(node.superclass)
+      emit_code(node.body, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
+    end
+
+    def visit_module_node(node)
+      emit_code(node.module_keyword_loc)
+      emit_code(node.constant_path)
+      emit_code(node.body, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
+    end
+
+    def visit_singleton_class_node(node)
+      emit_code(node.class_keyword_loc)
+      emit_code(node.operator_loc)
+      emit_code(node.expression)
+      emit_code(node.body, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
+    end
+
+    def visit_interpolated_x_string_node(node)
+      emit_code(node.opening_loc)
+      node.parts.each { |p| emit_code(p) }
+      emit_code(node.closing_loc, chomp: true)
+    end
+
+    def visit_for_node(node)
+      emit_code(node.for_keyword_loc)
+      emit_code(node.index)
+      emit_code(node.in_keyword_loc)
+      emit_code(node.collection)
+      emit_code(node.do_keyword_loc)
+      emit_code(node.statements, semicolon: true)
+      emit_code(node.end_keyword_loc, semicolon: true)
+    end
+
+    def visit_multi_target_node(node)
+      emit_code(node.lparen_loc)
+      comma = visit_comma_separated_nodes(node.lefts)
+      if node.rest
+        emit_comma if comma
+        emit_code(node.rest)
+        comma = true
+      end
+      visit_comma_separated_nodes(node.rights, comma)
+      emit_code(node.rparen_loc)
+    end
+
+    def visit_find_pattern_node(node)
+      emit_code(node.constant)
+      emit_code(node.opening_loc)
+      emit_code(node.left)
+      comma = node.left
+      comma = visit_comma_separated_nodes(node.requireds, comma)
+      if node.right
+        emit_comma if comma
+        emit_code(node.right)
+      end
+      emit_code(node.closing_loc)
+    end
+
+    def visit_array_pattern_node(node)
+      emit_code(node.constant)
+      emit_code(node.opening_loc)
+      comma = visit_comma_separated_nodes(node.requireds, comma)
+      if node.rest
+        emit_comma if comma
+        emit_code(node.rest)
+        comma = true
+      end
+      visit_comma_separated_nodes(node.posts, comma)
+      emit_code(node.closing_loc)
+    end
+
+    def visit_hash_pattern_node(node)
+      emit_code(node.constant)
+      emit_code(node.opening_loc)
+      visit_comma_separated_nodes(node.elements)
+      emit_code(node.closing_loc)
+    end
+
+    def visit_statements_node(node)
+      first = true
+      node.body&.each do |n|
+        @semicolon = !first
+        visit(n)
+        first = false
+      end
+    end
+
+    def visit_block_parameters_node(node)
+      emit_code(node.opening_loc)
+      emit_code(node.injected_parameters)
+      emit_code(node.parameters)
+      @semicolon = true if node.parameters
+      visit_comma_separated_nodes(node.locals)
+      emit_code(node.closing_loc)
+      @semicolon = false
+    end
+
+    def visit_lambda_node(node)
+      emit_code(node.operator_loc)
+      emit_code(node.parameters)
+      emit_code(node.opening_loc)
+      emit_code(node.body, semicolon: node.opening_loc.slice == 'do')
+      node.after_body_proc&.(node)
+      emit_code(node.closing_loc, semicolon: node.closing_loc.slice == 'end')
+    end
+
+    def visit_interpolated_regular_expression_node(node)
+      emit_code(node.opening_loc)
+      node.parts.each { |p| emit_code(p) }
+      emit_code(node.closing_loc)
+    end
+
+    def visit_super_node(node)
+      emit_code(node.keyword_loc)
+      emit_code(node.lparen_loc)
+      emit_code(node.arguments)
+      emit_block_pre_rparen = node.block.is_a?(Prism::BlockArgumentNode)
+      if emit_block_pre_rparen
+        emit_comma if node.arguments
+        emit_code(node.block)
+      end
+      emit_code(node.rparen_loc)
+      emit_code(node.block) if !emit_block_pre_rparen
+    end
+
+    def visit_undef_node(node)
+      emit_code(node.keyword_loc)
+      visit_comma_separated_nodes(node.names)
+    end
+
   end
 end

data/lib/sirop/version.rb

@@ -1,4 +1,4 @@
 module Sirop
   # Sirop version
-  VERSION = '0.3'
+  VERSION = '0.5'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sirop
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.5'
 platform: ruby
 authors:
 - Sharon Rosner
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-19 00:00:00.000000000 Z
+date: 2025-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.27.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.27.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.22.0
-description:
 email: sharon@noteflakes.com
 executables: []
 extensions: []
@@ -60,7 +58,6 @@ metadata:
   homepage_uri: https://github.com/digital-fabric/sirop
   documentation_uri: https://www.rubydoc.info/gems/sirop
   changelog_uri: https://github.com/digital-fabric/sirop/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options:
 - "--title"
 - Sirop
@@ -79,8 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: 'Sirop: Ruby code rewriter'
 test_files: []