Refactor to extract ResponseHandler class

Author: ledsun

ext/js/lib/js/require_remote.rb

@@ -1,80 +1,39 @@
 require "singleton"
 require "js"
-require_relative "./url_resolver"
+require_relative "./require_remote/url_resolver"
+require_relative "./require_remote/response_handler"
 
 module JS
-  ScriptLocation = Data.define(:url, :filename)
-
   class RequireRemote
     include Singleton
 
     def initialize
-      set_base_url
-
-      # The loaded URLs are saved as Ruby strings.
-      @loaded_urls = Set.new
+      base_url = JS.global[:URL].new(JS.global[:location][:href])
+      @resolver = URLResolver.new(base_url)
+      @handler =  ResponseHandler.new(method(:record_url))
     end
 
     # Load the given feature from remote.
     # The use_maps parameter is not used.
     # This is a parameter to keep the method name unchanged when supporting require methods.
     # Maps like import maps will be used.
     def load(relative_feature, use_maps: false)
-      location = get_location(relative_feature)
+      location = @resolver.get_location(relative_feature)
 
       # Do not load the same URL twice.
-      return false if @loaded_urls.include?(location.url[:href].to_s)
+      return false if @handler.evaluated?(location)
 
       response = JS.global.fetch(location.url).await
-
-      if response[:status].to_i == 200
-        # Check if the redirected URL has already loaded.
-        return false if @loaded_urls.include?(response[:url].to_s)
-
-        code = response.text().await.to_s
-        eval_code(code, location)
-
-        # The redirect that occurred may have been temporary.
-        # The original URL is not recorded.
-        # Only the URL after the redirect is recorded.
-        @loaded_urls << response[:url].to_s
-        true
-      else
-        raise LoadError.new "cannot load such url -- #{location.url}"
-      end
+      @handler.execute_and_record(response, location)
     end
 
     private
 
-    def set_base_url
-      base_url = JS.global[:URL].new(JS.global[:location][:href])
-      @resolver = URLResolver.new(base_url)
-    end
-
-    def get_location(relative_feature)
-      filename = filename_from(relative_feature)
-      url = resolver.resolve(filename)
-      ScriptLocation.new(url, filename)
-    end
-
-    # Evaluate the given Ruby code with the given location and save the URL to the stack.
-    def eval_code(code, location)
-      begin
-        resolver.push(location.url)
-        Kernel.eval(code, ::Object::TOPLEVEL_BINDING, location.filename)
-      ensure
-        resolver.pop
-      end
-    end
-
-    def filename_from(relative_feature)
-      if relative_feature.end_with?(".rb")
-        relative_feature
-      else
-        "#{relative_feature}.rb"
-      end
+    def record_url(url)
+      @resolver.push(url)
+      yield
+    ensure
+      @resolver.pop
     end
-
-    attr_reader :resolver
   end
 end

ext/js/lib/js/require_remote/response_handler.rb

@@ -0,0 +1,51 @@
+module JS
+  class RequireRemote
+    # Execute the body of the response and record the URL.
+    class ResponseHandler
+      # The around_eval parameter is a block that is executed before and after the body of the response.
+      # The block is passed the URL of the response.
+      def initialize(around_eval)
+        @around_eval = around_eval
+
+        # The evaluated URLs are saved as Ruby strings.
+        @evaluated_urls = Set.new
+      end
+
+      # Execute the body of the response and record the URL.
+      def execute_and_record(response, location)
+        if response[:status].to_i == 200
+          # Check if the redirected URL has already evaluated.
+          return false if url_evaluated?(response[:url].to_s)
+
+          code = response.text().await.to_s
+          evaluate(code, location)
+
+          # The redirect that occurred may have been temporary.
+          # The original URL is not recorded.
+          # Only the URL after the redirect is recorded.
+          @evaluated_urls << response[:url].to_s
+          true
+        else
+          raise LoadError.new "cannot load such url -- #{location.url}"
+        end
+      end
+
+      def evaluated?(location)
+        url_evaluated?(location.url[:href].to_s)
+      end
+
+      private
+
+      def url_evaluated?(url)
+        @evaluated_urls.include?(url)
+      end
+
+      # Evaluate the given Ruby code with the given location and save the URL to the stack.
+      def evaluate(code, location)
+        @around_eval.call(location.url) do
+          Kernel.eval(code, ::Object::TOPLEVEL_BINDING, location.filename)
+        end
+      end
+    end
+  end
+end

ext/js/lib/js/require_remote/url_resolver.rb

@@ -0,0 +1,45 @@
+module JS
+  class RequireRemote
+    ScriptLocation = Data.define(:url, :filename)
+
+    # When require_relative is called within a running Ruby script,
+    # the URL is resolved from a relative file path based on the URL of the running Ruby script.
+    # It uses a stack to store URLs of running Ruby Script.
+    # Push the URL onto the stack before executing the new script.
+    # Then pop it when the script has finished executing.
+    class URLResolver
+      def initialize(base_url)
+        @url_stack = [base_url]
+      end
+
+      def get_location(relative_feature)
+        filename = filename_from(relative_feature)
+        url = resolve(filename)
+        ScriptLocation.new(url, filename)
+      end
+
+      def push(url)
+        @url_stack.push url
+      end
+
+      def pop()
+        @url_stack.pop
+      end
+
+      private
+
+      def filename_from(relative_feature)
+        if relative_feature.end_with?(".rb")
+          relative_feature
+        else
+          "#{relative_feature}.rb"
+        end
+      end
+
+      # Return a URL object of JavaScript.
+      def resolve(relative_filepath)
+        JS.global[:URL].new relative_filepath, @url_stack.last
+      end
+    end
+  end
+end