klenod-build 0.0.26 → 0.0.27

data/lib/klenod/build/plugins/haml_plugin/transformer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "syntax_tree"
+require "prism"
 require "ripper"
 
 require "klenod/runtime/source_map"
@@ -681,16 +681,15 @@ module Klenod
                   builder.ruby_parse_error(source, line_no: node.line, context: "Could not parse Haml dynamic attributes")
                 end
 
-                hash.node.assocs.each do |assoc|
-                  if assoc.is_a?(SyntaxTree::AssocSplat)
-                    splat_source = hash.source[assoc.value.location.start_char...assoc.value.location.end_char]
+                hash.node.elements.each do |assoc|
+                  if assoc.is_a?(Prism::AssocSplatNode)
                     props[ATTRIBUTE_SPLATS_KEY] ||= []
-                    props[ATTRIBUTE_SPLATS_KEY] << builder.expression(splat_source)
+                    props[ATTRIBUTE_SPLATS_KEY] << builder.expression(assoc.value.slice)
                     next
                   end
 
                   key = attribute_key(assoc.key, builder: builder)
-                  value = event_handler_value(key, assoc.value, parenthesized: parenthesized, builder: builder) || attribute_value(assoc, builder: builder)
+                  value = event_handler_value(key, explicit_attribute_value(assoc), parenthesized: parenthesized, builder: builder) || attribute_value(assoc, builder: builder)
                   dynamic[key] = value
                   props[key] = value
                 end
@@ -799,8 +798,8 @@ module Klenod
             measure_compile(:haml_compile_object_ref_attributes) do
               expression = builder.expression(source, line_no: node.line)
               key =
-                if expression.node.is_a?(SyntaxTree::ArrayLiteral) && expression.node.contents&.parts&.length == 1
-                  builder.fragment(expression.node.contents.parts.fetch(0))
+                if expression.node.is_a?(Prism::ArrayNode) && expression.node.elements.length == 1
+                  builder.fragment(expression.node.elements.fetch(0))
                 else
                   expression
                 end
@@ -810,7 +809,7 @@ module Klenod
           end
 
           def attribute_value(assoc, builder:)
-            value = assoc.value
+            value = explicit_attribute_value(assoc)
             return builder.fragment(value) if value
 
             key = omitted_attribute_value_name(assoc.key)
@@ -819,6 +818,12 @@ module Klenod
             builder.ruby_parse_error(source, line_no: assoc.key.location&.start_line, context: "Could not parse Haml dynamic attributes")
           end
 
+          # `{title:}` omits the value, which Prism represents as an implicit
+          # node that slices back to the `title:` label.
+          def explicit_attribute_value(assoc)
+            assoc.value unless assoc.value.is_a?(Prism::ImplicitNode)
+          end
+
           def event_handler_value(key, value, parenthesized:, builder:)
             normalized_key = key.to_s.tr("-", "_")
             return unless normalized_key.match?(/\Aon(?:[a-z]|_[a-z])/)
@@ -836,36 +841,23 @@ module Klenod
 
           def omitted_attribute_value_name(node)
             case node
-            when SyntaxTree::Label
-              name = node.value.delete_suffix(":")
+            when Prism::SymbolNode
+              name = node.unescaped
               name if name.match?(/\A[a-zA-Z_]\w*\z/)
             end
           end
 
+          # Static keys (`title:`, `"data-id":`, `:title =>`, `"title" =>`) use
+          # their value. Interpolated keys keep their source.
           def attribute_key(node, builder:)
             case node
-            when SyntaxTree::Label
-              node.value.delete_suffix(":").to_sym
-            when SyntaxTree::DynaSymbol
-              static_dyna_symbol_value(node)&.to_sym || builder.fragment(node).source.to_sym
-            when SyntaxTree::StringLiteral
-              node.parts.map(&:value).join.to_sym
+            when Prism::SymbolNode, Prism::StringNode
+              node.unescaped.to_sym
             else
               builder.fragment(node).source.to_sym
             end
           end
 
-          def static_dyna_symbol_value(node)
-            values =
-              node.parts.map do |part|
-                return nil unless part.is_a?(SyntaxTree::TStringContent)
-
-                part.value
-              end
-
-            values.join
-          end
-
           def source_mark(node, builder:)
             builder.source_mark(node.line, nil)
           end

data/lib/klenod/build/plugins/haml_plugin.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "syntax_tree"
+require "prism"
 
 require_relative "../plugin"
 require_relative "../dependency"
@@ -301,13 +301,13 @@ module Klenod
           def validate_variable_receiver(kind, source)
             raise ArgumentError, "variables[#{kind.inspect}] must be a Ruby expression String" unless source.is_a?(String)
 
-            parsed = SyntaxTree.parse(source)&.statements&.body
-            raise ArgumentError, "variables[#{kind.inspect}] must be a Ruby expression" unless parsed&.length == 1
-            SyntaxTree.parse("(#{source})[:__klenod_variable__]")
+            parsed = Prism.parse(source)
+            expression = parsed.success? && parsed.value.statements.body.length == 1
+            unless expression && Prism.parse_success?("(#{source})[:__klenod_variable__]")
+              raise ArgumentError, "variables[#{kind.inspect}] must be a Ruby expression"
+            end
 
             source
-          rescue SyntaxTree::Parser::ParseError
-            raise ArgumentError, "variables[#{kind.inspect}] must be a Ruby expression"
           end
 
           def validate_i18n_options(i18n)

data/lib/klenod/build/plugins/ruby_plugin.rb

@@ -23,15 +23,7 @@ module Klenod
           private
 
           def location(error)
-            return prism_location(error) if error.is_a?(Prism::ParseResult)
-            return nil unless error.respond_to?(:lineno)
-
-            Location.new(
-              line: error.lineno,
-              # SyntaxTree reports a zero-based column.
-              column: error.column && error.column + 1,
-              detail: error.message
-            )
+            prism_location(error) if error.is_a?(Prism::ParseResult)
           end
 
           # Prism reports each failure as data rather than a message to scrape,
@@ -56,18 +48,14 @@ module Klenod
             program = parse!(module_id, code)
 
             result =
-              begin
-                RubyImportRewriter
-                  .new(
-                    module_id: module_id,
-                    kind: :ruby_import,
-                    source_dir: context.source_dir,
-                    profiler: context.profiler
-                  )
-                  .rewrite(code)
-              rescue SyntaxTree::Parser::ParseError => error
-                raise ParseError.new(error, source: code, module_id: module_id)
-              end
+              RubyImportRewriter
+                .new(
+                  module_id: module_id,
+                  kind: :ruby_import,
+                  source_dir: context.source_dir,
+                  profiler: context.profiler
+                )
+                .rewrite(code)
             TransformResult.new(
               result.code,
               result.dependencies,

data/lib/klenod/build/ruby_import_rewriter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
 require "ripper"
-require "syntax_tree"
 
 require_relative "dependency"
 require_relative "errors"
@@ -21,6 +21,8 @@ module Klenod
           end
         end
       Result = Data.define(:code, :dependencies, :watched_patterns)
+      # Character-based, so it indexes the source String directly.
+      CallLocation = Data.define(:start_line, :start_column, :start_char, :end_char)
 
       IMPORT_METHODS = {
         "import" => {
@@ -66,13 +68,20 @@ module Klenod
         fast_result = rewrite_literal_import_calls(code)
         return fast_result if fast_result
 
-        ast =
-          begin
-            measure(:ruby_import_parse) { SyntaxTree.parse(code) }
-          rescue SyntaxTree::Parser::ParseError => error
-            raise ParseError.new(error.message, line: error.lineno + @source_line_offset, column: error.column + 1 + @source_column_offset)
-          end
-        calls = measure(:ruby_import_scan) { import_calls(ast) }
+        # Haml `:ruby` filters are fragments, so accept top-level `yield`,
+        # `next`, and `break` like the rest of the Haml transform.
+        result = measure(:ruby_import_parse) { Prism.parse(code, partial_script: true) }
+        unless result.success?
+          # Prism first reports an unclosed `{` or `(` at the line that opens
+          # it. The unexpected token that broke it is the line to show.
+          error = result.errors.reject { it.type.end_with?("_term") }.min_by { it.location.start_offset } || result.errors.first
+          raise ParseError.new(
+            error.message,
+            line: error.location.start_line + @source_line_offset,
+            column: error.location.start_character_column + 1 + @source_column_offset
+          )
+        end
+        calls = measure(:ruby_import_scan) { import_calls(result.value) }
         expanded = expand_import_calls(calls)
 
         rewritten = measure(:ruby_import_rewrite_source) { rewrite_import_calls(code, expanded) }
@@ -180,121 +189,127 @@ module Klenod
       end
 
       def import_calls(node)
-        calls = []
-        walk(node) do |child|
-          if child.instance_of?(::SyntaxTree::CallNode)
-            next unless child.instance_variable_get(:@receiver).nil?
-            next unless IMPORT_METHODS.key?(child.instance_variable_get(:@message)&.value)
+        visitor = ImportCallVisitor.new
+        node.accept(visitor)
+        visitor.calls.map { |call| build_import_call(call) }
+      end
 
-            calls << build_import_call(child)
-          elsif child.instance_of?(::SyntaxTree::Command)
-            next unless IMPORT_METHODS.key?(child.instance_variable_get(:@message)&.value)
+      class ImportCallVisitor < Prism::Visitor
+        attr_reader :calls
 
-            calls << build_import_command(child)
-          end
+        def initialize
+          @calls = []
+          super
         end
-        calls
-      end
 
-      def build_import_call(node)
-        arguments = node.instance_variable_get(:@arguments)
-        parts = arguments&.instance_variable_get(:@arguments)&.instance_variable_get(:@parts) || []
-        build_import_from_parts(node, parts)
-      end
+        def visit_call_node(node)
+          @calls << node if import_call?(node)
+          super
+        end
+
+        private
 
-      def build_import_command(node)
-        arguments = node.instance_variable_get(:@arguments)
-        parts = arguments&.instance_variable_get(:@parts) || []
-        build_import_from_parts(node, parts)
+        # A bare `import` without arguments or parentheses is an ordinary
+        # method call or local variable, not an import.
+        def import_call?(node)
+          node.receiver.nil? &&
+            IMPORT_METHODS.key?(node.name.to_s) &&
+            !(node.arguments.nil? && node.opening_loc.nil?)
+        end
       end
+      private_constant :ImportCallVisitor
 
-      def build_import_from_parts(node, parts)
-        return build_import_glob_from_parts(node, parts) if node.instance_variable_get(:@message).value == "import_glob"
+      def build_import_call(node)
+        arguments = node.arguments&.arguments || []
+        return build_import_glob(node, arguments) if node.name == :import_glob
 
-        first = unwrap_paren(parts.first)
-        string_parts = first&.instance_variable_get(:@parts)
-        literal_specifier =
-          first&.class&.name == "SyntaxTree::StringLiteral" &&
-          string_parts&.length == 1 &&
-          string_parts.first.instance_of?(::SyntaxTree::TStringContent)
-        import_name = (parts.length == 2) ? constant_symbol_value(parts.fetch(1)) : nil
-        literal = literal_specifier && (parts.length == 1 || !import_name.nil?)
+        specifier = string_literal_value(arguments.first)
+        import_name = (arguments.length == 2) ? constant_symbol_value(arguments.fetch(1)) : nil
+        literal = !specifier.nil? && (arguments.length == 1 || !import_name.nil?)
 
         ImportCall.new(
-          literal ? string_parts.first.value : nil,
-          node.instance_variable_get(:@location),
+          literal ? specifier : nil,
+          call_location(node),
           !literal,
-          node.instance_variable_get(:@message).value,
+          node.name.to_s,
           nil,
           literal ? import_name : nil
         )
       end
 
+      # A Prism call's location includes an attached block, so the rewritten
+      # range ends at the closing parenthesis or the last argument.
+      def call_location(node)
+        last = node.closing_loc || node.arguments&.location || node.message_loc
+
+        CallLocation.new(
+          node.location.start_line,
+          node.location.start_character_column,
+          node.location.start_character_offset,
+          last.end_character_offset
+        )
+      end
+
+      # A plain string literal without interpolation, such as `"./Card.haml"`.
+      def string_literal_value(node)
+        node = unwrap_parentheses(node)
+        return unless node.is_a?(Prism::StringNode) && !node.heredoc? && !node.unescaped.empty?
+
+        node.unescaped
+      end
+
       # The optional second argument of `import`: a symbol literal spelled like
       # a constant, such as `:Bar`. Anything else (`:bar`, `:"Bar"`, a string,
       # a variable) is reported as a dynamic import.
       def constant_symbol_value(node)
-        return unless node.instance_of?(::SyntaxTree::SymbolLiteral)
+        return unless node.is_a?(Prism::SymbolNode) && node.opening_loc&.slice == ":"
 
-        value = node.instance_variable_get(:@value)
-        value.instance_of?(::SyntaxTree::Const) ? value.value.to_sym : nil
+        value = node.unescaped
+        value.match?(/\A[A-Z]\w*\z/) ? value.to_sym : nil
       end
 
-      def build_import_glob_from_parts(node, parts)
-        first = unwrap_paren(parts.first)
-        string_parts = first&.instance_variable_get(:@parts)
-        literal =
-          first&.class&.name == "SyntaxTree::StringLiteral" &&
-          string_parts&.length == 1 &&
-          string_parts.first.instance_of?(::SyntaxTree::TStringContent)
+      def build_import_glob(node, arguments)
+        specifier = string_literal_value(arguments.first)
+        literal = !specifier.nil?
 
         eager = true
         valid_options = true
-        if parts.length == 2
-          eager = eager_option_value(parts.fetch(1))
+        if arguments.length == 2
+          eager = eager_option_value(arguments.fetch(1))
           valid_options = !eager.nil?
-        elsif parts.length != 1
+        elsif arguments.length != 1
           valid_options = false
         end
 
         ImportCall.new(
-          (literal && valid_options) ? string_parts.first.value : nil,
-          node.instance_variable_get(:@location),
+          (literal && valid_options) ? specifier : nil,
+          call_location(node),
           !literal || !valid_options,
-          node.instance_variable_get(:@message).value,
+          node.name.to_s,
           eager,
           nil
         )
       end
 
       def eager_option_value(node)
-        return unless node.instance_of?(::SyntaxTree::BareAssocHash)
-
-        assocs = node.instance_variable_get(:@assocs)
-        return unless assocs.length == 1
+        return unless node.is_a?(Prism::KeywordHashNode) && node.elements.length == 1
 
-        assoc = assocs.fetch(0)
-        key = assoc.instance_variable_get(:@key)
-        return unless key.instance_of?(::SyntaxTree::Label) && key.value == "eager:"
+        assoc = node.elements.fetch(0)
+        return unless assoc.is_a?(Prism::AssocNode)
 
-        bool_value(assoc.instance_variable_get(:@value))
-      end
-
-      def bool_value(node)
-        return unless node.instance_of?(::SyntaxTree::VarRef)
+        key = assoc.key
+        return unless key.is_a?(Prism::SymbolNode) && key.opening_loc.nil? && key.unescaped == "eager"
 
-        value = node.instance_variable_get(:@value)
-        return true if value.respond_to?(:value) && value.value == "true"
-        return false if value.respond_to?(:value) && value.value == "false"
-
-        nil
+        case assoc.value
+        when Prism::TrueNode then true
+        when Prism::FalseNode then false
+        end
       end
 
-      def unwrap_paren(node)
-        return node unless node.instance_of?(::SyntaxTree::Paren)
+      def unwrap_parentheses(node)
+        return node unless node.is_a?(Prism::ParenthesesNode)
 
-        statements = node.instance_variable_get(:@contents)
-        body = statements&.instance_variable_get(:@body) || []
+        body = node.body.is_a?(Prism::StatementsNode) ? node.body.body : []
         (body.length == 1) ? body.first : node
       end
 
@@ -455,21 +470,6 @@ module Klenod
             rewritten[location.start_char...location.end_char] = import.replacement_source
           end
       end
-
-      def walk(value, &block)
-        yield value
-
-        case value
-        when Array
-          value.each { |item| walk(item, &block) }
-        else
-          return unless value.respond_to?(:instance_variables)
-
-          value.instance_variables.each do |ivar|
-            walk(value.instance_variable_get(ivar), &block)
-          end
-        end
-      end
     end
   end
 end

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.26"
+    VERSION = "0.0.27"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.27
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.26
+        version: 0.0.27
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.26
+        version: 0.0.27
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -85,6 +85,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: image_size
   requirement: !ruby/object:Gem::Requirement
@@ -142,75 +156,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.10'
 - !ruby/object:Gem::Dependency
-  name: protocol-url
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.4'
-- !ruby/object:Gem::Dependency
-  name: rmagick
+  name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
-  name: samovar
+  name: protocol-url
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: syntax_tree
+  name: rmagick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.3'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.3'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: syntax_tree-haml
+  name: samovar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: toml-rb
   requirement: !ruby/object:Gem::Requirement