Release cached files after OpenapiFirst.load

Make FileLoader and RefResolver classes

Author: ahx

lib/openapi_first.rb

@@ -22,11 +22,6 @@ module OpenapiFirst
 
   FAILURE = :openapi_first_validation_failure
 
-  # Clears cached files
-  def self.clear_cache!
-    FileLoader.clear_cache!
-  end
-
   # @return [Configuration]
   def self.configuration
     @configuration ||= Configuration.new

lib/openapi_first/builder.rb

@@ -27,18 +27,20 @@ def initialize(contents, filepath:, config:)
       meta_schema = detect_meta_schema(contents, filepath)
       @schemer_configuration = build_schemer_config(filepath:, meta_schema:)
       @config = config
-      @contents = RefResolver.for(contents, filepath:)
+      @file_loader = FileLoader.new
+      ref_resolver = RefResolver.new(file_loader:)
+      @contents = ref_resolver.for(contents, filepath:)
     end
 
     attr_reader :config
-    private attr_reader :schemer_configuration
+    private attr_reader :schemer_configuration, :file_loader
 
     def build_schemer_config(filepath:, meta_schema:)
       result = JSONSchemer.configuration.clone
       dir = (filepath && File.absolute_path(File.dirname(filepath))) || Dir.pwd
       result.base_uri = URI::File.build({ path: "#{dir}/" })
       result.ref_resolver = JSONSchemer::CachedResolver.new do |uri|
-        FileLoader.load(uri.path)
+        file_loader.load(uri.path)
       end
       result.meta_schema = meta_schema
       result.insert_property_defaults = true

lib/openapi_first/file_loader.rb

@@ -5,11 +5,15 @@
 
 module OpenapiFirst
   # @!visibility private
-  module FileLoader
-    @cache = {}
-    @mutex = Mutex.new
+  class FileLoader
+    def self.load(file_path)
+      new.load(file_path)
+    end
 
-    module_function
+    def initialize
+      @cache = {}
+      @mutex = Mutex.new
+    end
 
     def load(file_path)
       @cache[file_path] || @mutex.synchronize do
@@ -29,9 +33,5 @@ def load(file_path)
         end
       end
     end
-
-    def clear_cache!
-      @mutex.synchronize { @cache.clear }
-    end
   end
 end

lib/openapi_first/ref_resolver.rb

@@ -5,30 +5,42 @@
 module OpenapiFirst
   # This is here to give traverse an OAD while keeping $refs intact
   # @visibility private
-  module RefResolver
-    def self.load(filepath)
-      contents = OpenapiFirst::FileLoader.load(filepath)
+  class RefResolver
+    def initialize(file_loader:)
+      @file_loader = file_loader
+    end
+
+    private attr_reader :file_loader
+
+    def load(filepath)
+      contents = file_loader.load(filepath)
       self.for(contents, filepath:)
     end
 
-    def self.for(value, filepath: nil, context: value)
+    def for(value, filepath: nil, context: value)
       case value
       when ::Hash
-        resolver = Hash.new(value, context:, filepath:)
+        resolver = Hash.new(value, context:, filepath:, ref_resolver: self)
         if value.key?('$ref')
           probe = resolver.resolve_ref(value['$ref'])
           return probe if probe.is_a?(Array)
         end
         resolver
       when ::Array
-        Array.new(value, context:, filepath:)
+        Array.new(value, context:, filepath:, ref_resolver: self)
       when ::NilClass
         nil
       else
-        Simple.new(value)
+        Simple.new(value, ref_resolver: self)
       end
     end
 
+    def file_at(filepath, file_pointer)
+      file_contents = file_loader.load(filepath)
+      value = Hana::Pointer.new(file_pointer).eval(file_contents)
+      self.for(value, filepath: filepath, context: file_contents)
+    end
+
     # @visibility private
     module Diggable
       def dig(*keys)
@@ -42,10 +54,11 @@ def dig(*keys)
 
     # @visibility private
     module Resolvable
-      def initialize(value, context: value, filepath: nil)
+      def initialize(value, ref_resolver:, context: value, filepath: nil)
         @value = value
         @context = context
         @filepath = filepath
+        @ref_resolver = ref_resolver
         @dir = if filepath
                  File.dirname(File.absolute_path(filepath))
                else
@@ -62,6 +75,8 @@ def initialize(value, context: value, filepath: nil)
 
       attr_reader :filepath
 
+      private attr_reader :ref_resolver
+
       def ==(_other)
         raise "Don't call == on an unresolved value. Use .value == other instead."
       end
@@ -71,16 +86,14 @@ def resolve_ref(pointer)
           value = Hana::Pointer.new(pointer[1..]).eval(context)
           raise "Unknown reference #{pointer} in #{context}" unless value
 
-          return RefResolver.for(value, filepath:, context:)
+          return ref_resolver.for(value, filepath:, context:)
         end
 
         relative_path, file_pointer = pointer.split('#')
         full_path = File.expand_path(relative_path, dir)
-        return RefResolver.load(full_path) unless file_pointer
+        return ref_resolver.load(full_path) unless file_pointer
 
-        file_contents = FileLoader.load(full_path)
-        value = Hana::Pointer.new(file_pointer).eval(file_contents)
-        RefResolver.for(value, filepath: full_path, context: file_contents)
+        ref_resolver.file_at(full_path, file_pointer)
       rescue OpenapiFirst::FileNotFoundError => e
         message = "Problem with reference resolving #{pointer.inspect} in " \
                   "file #{File.absolute_path(filepath).inspect}: #{e.message}"
@@ -114,13 +127,13 @@ def resolved
       def [](key)
         return resolve_ref(@value['$ref'])[key] if !@value.key?(key) && @value.key?('$ref')
 
-        RefResolver.for(@value[key], filepath:, context:)
+        ref_resolver.for(@value[key], filepath:, context:)
       end
 
       def fetch(key)
         return resolve_ref(@value['$ref']).fetch(key) if !@value.key?(key) && @value.key?('$ref')
 
-        RefResolver.for(@value.fetch(key), filepath:, context:)
+        ref_resolver.for(@value.fetch(key), filepath:, context:)
       end
 
       def each
@@ -170,7 +183,7 @@ def [](index)
         item = @value[index]
         return resolve_ref(item['$ref']) if item.is_a?(::Hash) && item.key?('$ref')
 
-        RefResolver.for(item, filepath:, context:)
+        ref_resolver.for(item, filepath:, context:)
       end
 
       def each

spec/openapi_first_spec.rb

@@ -52,15 +52,6 @@
     end
   end
 
-  describe '.clear_cache!' do
-    it 'clears the file cache so files are reloaded on next load' do
-      first = OpenapiFirst.load(spec_path)
-      OpenapiFirst.clear_cache!
-      second = OpenapiFirst.load(spec_path)
-      expect(second).not_to be(first)
-    end
-  end
-
   describe '.load' do
     begin
       require 'multi_json'