sirop 0.2 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1641ee60187094fe9dcdeebefbfc5283c0d2ea535aa161b17f7bf6f720d63854
-  data.tar.gz: c9abaef1a8b7116760f92e143bcb2e58fbc4424fe3d4afe110bc10bf552852cf
+  metadata.gz: b6ffcc66301949fc52bae4b2eef554243263b06a9bdf699d6be61d9d38f1ade1
+  data.tar.gz: 6aeba8547c161f56a20e64d7cf219489bfd0f2195063ca8b651c821134944232
 SHA512:
-  metadata.gz: 3900ece58c932df6181676abb597fa6deedfbd8801e28f4993cc36cce7584a188e88b73e6ef2b0fea33b5dbc8a8d284949159973cb108e149dd0d9b3ea5dd762
-  data.tar.gz: 7f848b0e842792a33e3fc7c9b7d6cf72e924040307e2db5ccb0cff16af1e947e7053ee81e54ab688c131532b66432dc1283651ceeef5820ded58c3b8447d193a
+  metadata.gz: 8dde7126119287b24f05352b5c62922a5023c80ff9ffb3f258ddf8824b6ce947b7f2551bc1818202036ac152815458e3126a838b3e91d147ed413cb6fb181818
+  data.tar.gz: 83856a27062116324228881ff61172c62234ca3ce6992ba5ef8355db3f5a823e018695eb6e9e61b61b852cfa1b497039c1ad3fcbf6e7451bb0a9b14b64801da0

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 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
+- Fix whitespace adjustment in DSL compiler
+- Improve DSL compiler to support embedded string expressions
+- Correctly handle eval'd proc
+
 # 2024-02-27 0.2
 
 - Update README

data/lib/sirop/injection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sirop
+  class Injection
+    attr_reader :slice
+
+    def initialize(slice)
+      @slice = slice
+    end
+  end
+end

data/lib/sirop/prism_ext.rb

@@ -8,3 +8,27 @@ class Prism::BasicVisitor
     self
   end
 end
+
+class Prism::ParametersNode
+  attr_accessor :injected_prefix
+end
+
+class Prism::BlockParametersNode
+  attr_accessor :injected_parameters
+end
+
+class Prism::LambdaNode
+  # @param params [String] injected parameters
+  # @return [void]
+  def inject_parameters(params)
+    if parameters
+      if parameters.parameters
+        parameters.parameters.injected_prefix = Sirop::Injection.new(params)
+      else
+        parameters.injected_parameters = Sirop::Injection.new(params)
+      end
+    else
+      instance_variable_set(:@parameters, Sirop::Injection.new("(#{params})"))
+    end
+  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
@@ -30,11 +114,14 @@ module Sirop
     end
 
     def adjust_whitespace(loc)
+      return if loc.is_a?(Sirop::Injection)
+
       if @last_loc_start
-        if @last_loc_end.first != loc.start_line
-          @buffer << "\n" * (loc.start_line - @last_loc_end.first)
+        line_diff = loc.start_line - @last_loc_end.first
+        if line_diff > 0
+          @buffer << "\n" * line_diff
           @buffer << ' ' * loc.start_column
-        else
+        elsif line_diff == 0
           ofs = loc.start_column - @last_loc_end.last
           if ofs > 0
             @buffer << ' ' * ofs
@@ -49,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
@@ -74,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)
@@ -84,41 +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, :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],
-      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],
-      or:                     [:left, :operator_loc, :right],
-      parentheses:            [:opening_loc, :body, :closing_loc],
-      required_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) }
@@ -142,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
@@ -151,15 +221,40 @@ 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 = visit_comma_separated_nodes(node.requireds)
+      comma = false
+      # injected_prefix is a custom attribute added by Sirop to the
+      # ParametersNode class (in lib/sirop/prism_ext.rb). It is used
+      # as a way to add a first parameter to a block or method.
+      if node.injected_prefix
+        emit_code(node.injected_prefix)
+        # adjust last_loc_end for proper whitespace after comma
+        @last_loc_end[1] -= 2 if @last_loc_end
+        # binding.irb
+        comma = true
+      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)
       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
@@ -172,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)
@@ -190,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)
@@ -208,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)
@@ -230,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
@@ -269,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)
@@ -286,5 +440,241 @@ 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')
+      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.2'
+  VERSION = '0.4'
 end

data/lib/sirop.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require 'prism'
+require 'sirop/injection'
 require 'sirop/prism_ext'
 require 'sirop/finder'
 require 'sirop/sourcifier'
 
 module Sirop
+  class Error < StandardError
+  end
+
   class << self
     def to_ast(obj)
       case obj
@@ -43,6 +47,8 @@ module Sirop
           super(node)
         end
       end
+    rescue Errno::ENOENT
+      raise Sirop::Error, "Could not get source for proc"
     end
 
     def method_ast(method)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sirop
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.4'
 platform: ruby
 authors:
 - Sharon Rosner
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-27 00:00:00.000000000 Z
+date: 2024-04-29 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: []
@@ -49,6 +47,7 @@ files:
 - README.md
 - lib/sirop.rb
 - lib/sirop/finder.rb
+- lib/sirop/injection.rb
 - lib/sirop/prism_ext.rb
 - lib/sirop/sourcifier.rb
 - lib/sirop/version.rb
@@ -59,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
@@ -78,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.0.dev
 specification_version: 4
 summary: 'Sirop: Ruby code rewriter'
 test_files: []