Use constant array

Author: ntkme

lib/sass/compiler/host/importer_registry.rb

@@ -25,6 +25,12 @@ def initialize(importers, load_paths, alert_color:)
           @highlight = alert_color
         end
 
+        IMPORTER_ATTRS = %i[non_canonical_scheme].freeze
+
+        IMPORTER_METHODS = %i[canonicalize load find_file_url].freeze
+
+        private_constant :IMPORTER_ATTRS, :IMPORTER_METHODS
+
         def register(importer)
           if importer.is_a?(Sass::NodePackageImporter)
             EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
@@ -33,8 +39,7 @@ def register(importer)
               )
             )
           else
-            importer = Struct.from_hash(importer, attrs: %i[non_canonical_scheme],
-                                                  methods: %i[canonicalize load find_file_url])
+            importer = Struct.new(importer, attrs: IMPORTER_ATTRS, methods: IMPORTER_METHODS) if importer.is_a?(::Hash)
 
             is_importer = importer.respond_to?(:canonicalize) && importer.respond_to?(:load)
             is_file_importer = importer.respond_to?(:find_file_url)
@@ -80,10 +85,14 @@ def canonicalize(canonicalize_request)
           )
         end
 
+        IMPORTER_RESULT_ATTRS = %i[contents syntax source_map_url].freeze
+
+        private_constant :IMPORTER_RESULT_ATTRS
+
         def import(import_request)
           importer = @importers_by_id[import_request.importer_id]
-          importer_result = Struct.from_hash(importer.load(import_request.url),
-                                             attrs: %i[contents syntax source_map_url])
+          importer_result = importer.load(import_request.url)
+          importer_result = Struct.new(importer_result, attrs: IMPORTER_RESULT_ATTRS) if importer_result.is_a?(::Hash)
 
           EmbeddedProtocol::InboundMessage::ImportResponse.new(
             id: import_request.id,

lib/sass/compiler/host/logger_registry.rb

@@ -7,22 +7,26 @@ class Host
       #
       # It stores logger and handles log events.
       class LoggerRegistry
+        LOGGER_METHODS = %i[warn debug].freeze
+
+        private_constant :LOGGER_METHODS
+
         def initialize(logger)
-          @logger = Struct.from_hash(logger, methods: %i[debug warn])
-          @respond_to_debug = @logger.respond_to?(:debug)
-          @respond_to_warn = @logger.respond_to?(:warn)
+          @logger = logger.is_a?(::Hash) ? Struct.new(logger, methods: LOGGER_METHODS) : logger
+          @logger_respond_to_debug = @logger.respond_to?(:debug)
+          @logger_respond_to_warn = @logger.respond_to?(:warn)
         end
 
         def log(event)
           case event.type
           when :DEBUG
-            if @respond_to_debug
+            if @logger_respond_to_debug
               @logger.debug(event.message, DebugContext.new(event))
             else
               Kernel.warn(event.formatted)
             end
           when :DEPRECATION_WARNING, :WARNING
-            if @respond_to_warn
+            if @logger_respond_to_warn
               @logger.warn(event.message, WarnContext.new(event))
             else
               Kernel.warn(event.formatted)

lib/sass/compiler/host/struct.rb

@@ -3,9 +3,9 @@
 module Sass
   class Compiler
     class Host
-      # The {Struct} module.
+      # The {Struct} class.
       #
-      # It creates {Struct}-like objects from {::Hash}.
+      # It creates {::Struct}-like objects from {::Hash}.
       class Struct
         def initialize(hash, attrs: nil, methods: nil)
           @hash = hash
@@ -28,16 +28,6 @@ def method_missing(symbol, ...)
         def respond_to_missing?(symbol, _include_all)
           @hash.key?(symbol) && (@attrs&.include?(symbol) || @methods&.include?(symbol))
         end
-
-        class << self
-          def from_hash(object, ...)
-            if object.is_a?(Hash)
-              new(object, ...)
-            else
-              object
-            end
-          end
-        end
       end
 
       private_constant :Struct

lib/sass/value/number.rb

@@ -25,12 +25,12 @@ def initialize(value, unit = nil)
           denominator_units = []
         when ::Hash
           numerator_units = unit.fetch(:numerator_units, [])
-          unless numerator_units.is_a?(Array)
+          unless numerator_units.is_a?(::Array)
             raise Sass::ScriptError, "invalid numerator_units #{numerator_units.inspect}"
           end
 
           denominator_units = unit.fetch(:denominator_units, [])
-          unless denominator_units.is_a?(Array)
+          unless denominator_units.is_a?(::Array)
             raise Sass::ScriptError, "invalid denominator_units #{denominator_units.inspect}"
           end
         else