chore: add specs for forge

Author: jacobobq

lib/forge.rb

@@ -24,19 +24,21 @@ def forge(concept)
     # Find things that need to be deleted and things that are up to date
     synthesizers.each do |synthesizer|
       template = synthesizer.path_template(concept)
-      existing_file = template.existing_file
+      existing_signature = template.existing_signature
 
       # File does not exist, can not be up to date
-      next unless existing_file
+      next unless existing_signature
 
       # File exists but the synthesizer no longer works on it, delete it
       unless synthesizer.synthesizes?(concept)
-        next pending_deletions << existing_file
+        next pending_deletions << template.full_path(existing_signature)
       end
 
-      file_signature = template.parse_signature_from_file(existing_file)
       # File exists and the synthesizer has pending work
-      next up_to_date << synthesizer if file_signature != concept.signature
+      next up_to_date << synthesizer if existing_signature == concept.signature
+
+      # File exists but the signature is different, delete it
+      pending_deletions << template.full_path(existing_signature)
     end
 
     # Delete generated files that are no longer needed

lib/forge/path_template.rb

@@ -20,7 +20,7 @@ def initialize(path:, basename:, extension:)
       @basename = basename
       @extension = extension
       @filename_regex = T.let(nil, T.nilable(Regexp))
-      @existing_file = T.let(nil, T.nilable(String))
+      @existing_signature = T.let(nil, T.nilable(String))
     end
 
     sig { params(signature: String).returns(String) }
@@ -33,30 +33,24 @@ def full_path(signature)
       File.join(path, filename(signature))
     end
 
-    sig { params(path: String).returns(String) }
-    def parse_signature_from_file(path)
-      match = path.match(filename_regex)
-      unless match
-        raise BadSignatureError, "Cannot parse signature from #{path}"
-      end
-      T.must(match[1])
-    end
-
     sig { returns(T.nilable(String)) }
-    def existing_file
-      @existing_file ||= find_existing_file
+    def existing_signature
+      @existing_signature ||= find_existing_signature
     end
 
     private
 
     sig { returns(T.nilable(String)) }
-    def find_existing_file
+    def find_existing_signature
       signatures =
         Dir
           .glob(glob)
           .filter_map do |path|
-            match = path.match(filename_regex)
-            raise BadSignatureError, "Bad signature found: #{path}" unless match
+            basename = File.basename(path)
+            match = basename.match(filename_regex)
+            unless match
+              raise BadSignatureError, "Bad signature found: #{basename}"
+            end
             match[1]
           end
 
@@ -73,7 +67,7 @@ def glob
 
     sig { returns(Regexp) }
     def filename_regex
-      @filename_regex ||= Regexp.new("#{basename}\.(\H+)\.#{extension}", "i")
+      @filename_regex ||= Regexp.new("#{basename}\\.(\\h+)\\.#{extension}", "i")
     end
 
     sig { returns(String) }

spec/forge_spec.rb

@@ -2,30 +2,80 @@
 # typed: false
 
 require "spec_helper"
-require_relative "./fake_synthesizer"
+require_relative "./mock_synthesizer"
+require_relative "./mock_concept"
 require_relative "../lib/forge"
+require "fileutils"
 
 RSpec.describe Forge do
   let(:forge) { Forge.new }
-  let(:concept) { FakeConcept.new }
+  let(:concept) { MockConcept.new }
+  let(:path_template) do
+    Forge::PathTemplate.new(
+      path: MockSynthesizer::PATH,
+      basename: MockSynthesizer::BASENAME,
+      extension: MockSynthesizer::EXTENSION
+    )
+  end
+  let(:synthesizer) { MockSynthesizer.new }
 
   describe "#forge" do
-    before { forge.register_synthesizer(FakeSynthesizer.new) }
+    before do
+      if Dir.exist?(MockSynthesizer::PATH)
+        FileUtils.rm_rf(MockSynthesizer::PATH)
+      end
+
+      forge.register_synthesizer(synthesizer)
+      FileUtils.mkdir_p(MockSynthesizer::PATH)
+    end
 
-    subject! { forge.forge(concept) }
+    after { FileUtils.rm_rf(MockSynthesizer::PATH) }
 
     it "forges an artifact" do
-      expect(
-        File.exist?(
-          File.join(
-            Forge::PathTemplate.new(
-              path: FakeSynthesizer.PATH,
-              basename: FakeSynthesizer.BASENAME,
-              extension: FakeSynthesizer.EXTENSION
-            ).full_path(concept.signature)
-          )
-        )
-      ).to be_truthy
+      forge.forge(concept)
+      expected_path = path_template.full_path(concept.signature)
+      expect(File.exist?(expected_path)).to be_truthy
+      expect(File.read(expected_path)).to eq(synthesizer.content)
+    end
+
+    it "deletes an artifact" do
+      forge.forge(concept)
+      expected_path = path_template.full_path(concept.signature)
+      expect(File.exist?(expected_path)).to be_truthy
+
+      synthesizer.synthesizes = false
+      forge.forge(concept)
+      expect(File.exist?(expected_path)).to be_falsey
+    end
+
+    it "rebuilds an artifact when signature changes" do
+      forge.forge(concept)
+      initial_path = path_template.full_path(concept.signature)
+
+      expect(File.exist?(initial_path)).to be_truthy
+      expect(File.read(initial_path)).to eq(synthesizer.content)
+
+      concept.dump = { foo: "bar" }
+      synthesizer.content = "A different content"
+      expected_path = path_template.full_path(concept.signature)
+      forge.forge(concept)
+
+      expect(File.exist?(initial_path)).to be_falsey
+      expect(File.exist?(expected_path)).to be_truthy
+      expect(File.read(expected_path)).to eq(synthesizer.content)
+    end
+
+    it "doesn't rebuild an artifact when signature is the same" do
+      forge.forge(concept)
+      initial_path = path_template.full_path(concept.signature)
+      expect(File.exist?(initial_path)).to be_truthy
+      expect(File.read(initial_path)).to eq(synthesizer.content)
+      initial_modified_time = File.mtime(initial_path)
+
+      forge.forge(concept)
+      expect(File.exist?(initial_path)).to be_truthy
+      expect(File.read(initial_path)).to eq(synthesizer.content)
+      expect(File.mtime(initial_path)).to eq(initial_modified_time)
     end
   end
 end

spec/fake_concept.rb spec/mock_concept.rb

@@ -1,13 +1,21 @@
 # typed: strict
 # frozen_string_literal: true
 
-class FakeConcept
+class MockConcept
   extend T::Sig
   include Forge::Concept
 
+  sig { void }
+  def initialize
+    @dump = T.let({}, T::Hash[Symbol, T.untyped])
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  attr_accessor :dump
+
   sig { override.returns(T::Hash[Symbol, T.untyped]) }
   def dump
-    {}
+    @dump
   end
 
   sig { override.returns(Symbol) }

spec/fake_synthesizer.rb spec/mock_synthesizer.rb

@@ -2,32 +2,42 @@
 # frozen_string_literal: true
 
 require_relative "../lib/forge/synthesizer"
-require_relative "./fake_concept"
 
-class FakeSynthesizer
+class MockSynthesizer
   extend T::Sig
   include Forge::Synthesizer
 
   NAME = "Dummy Synthesizer"
-  CONTENT = "This is a dummy synthesizer"
   PATH = "tmp/dummy"
   BASENAME = "dummy"
   EXTENSION = "txt"
 
+  sig { void }
+  def initialize
+    @synthesizes = T.let(true, T::Boolean)
+    @content = T.let("This is a dummy synthesizer", String)
+  end
+
   sig { override.returns(String) }
   def name
     NAME
   end
 
+  sig { returns(T::Boolean) }
+  attr_accessor :synthesizes
+
+  sig { returns(String) }
+  attr_accessor :content
+
   sig { override.params(concept: Forge::Concept).returns(T::Boolean) }
   def synthesizes?(concept)
-    true
+    synthesizes
   end
 
   sig { override.params(concept: Forge::Concept).returns(Forge::Artifact) }
   def synthesize(concept)
     Forge::Artifact.new(
-      content: CONTENT,
+      content: content,
       path_template: path_template(concept),
       signature: concept.signature
     )