feat: implement artifact forge

Author: jacobobq

lib/forge.rb

@@ -0,0 +1,65 @@
+# typed: strict
+
+require_relative "forge/synthesizer"
+require_relative "forge/concept"
+
+class Forge
+  extend T::Sig
+
+  sig { void }
+  def initialize
+    @synthesizers = T.let(Set.new, T::Set[Forge::Synthesizer])
+  end
+
+  sig { params(synthesizer: Forge::Synthesizer).void }
+  def register_synthesizer(synthesizer)
+    synthesizers << synthesizer
+  end
+
+  sig { params(concept: Forge::Concept).void }
+  def forge(concept)
+    pending_deletions = Set.new
+    up_to_date = Set.new
+
+    # 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
+
+      # File does not exist, can not be up to date
+      next unless existing_file
+
+      # File exists but the synthesizer no longer works on it, delete it
+      unless synthesizer.synthesizes?(concept)
+        next pending_deletions << existing_file
+      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
+    end
+
+    # Delete generated files that are no longer needed
+    T.unsafe(File).delete(*pending_deletions)
+
+    need_rebuild = synthesizers_for(concept) - up_to_date
+
+    # Find all synthesizers for the concept and synthesize
+    need_rebuild.each do |synthesizer|
+      artifact = synthesizer.synthesize(concept)
+      artifact.write!
+    end
+  end
+
+  private
+
+  sig { params(concept: Forge::Concept).returns(T::Set[Forge::Synthesizer]) }
+  def synthesizers_for(concept)
+    Set.new(
+      synthesizers.filter { |synthesizer| synthesizer.synthesizes?(concept) }
+    )
+  end
+
+  sig { returns(T::Set[Forge::Synthesizer]) }
+  attr_reader :synthesizers
+end

lib/forge/artifact.rb

@@ -0,0 +1,39 @@
+# typed: strict
+
+require_relative "path_template"
+
+class Forge
+  # The `Artifact` class represents the result of a `Synthesizer` in the form of
+  # a file that can be written to disk.
+  class Artifact
+    extend T::Sig
+
+    sig do
+      params(
+        content: String,
+        path_template: Forge::PathTemplate,
+        signature: String
+      ).void
+    end
+    def initialize(content:, path_template:, signature:)
+      @content = content
+      @path_template = path_template
+      @signature = signature
+    end
+
+    sig { returns(String) }
+    attr_reader :content
+
+    sig { returns(Forge::PathTemplate) }
+    attr_reader :path_template
+
+    sig { returns(String) }
+    attr_reader :signature
+
+    sig { void }
+    def write!
+      path = path_template.full_path(signature)
+      File.write(path, content)
+    end
+  end
+end

lib/forge/concept.rb

@@ -0,0 +1,35 @@
+# typed: strict
+
+class Forge
+  # The `Concept` interface represents any entity in the resource registry system
+  # that can be used as a source for artifact synthesis. This includes resources,
+  # schemas, verbs, and any future concepts that may be added.
+  #
+  # Implementing classes should provide methods for generating signatures and
+  # supporting composition with other concepts.
+  module Concept
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    # Returns a unique identifier for this concept
+    sig { abstract.returns(Symbol) }
+    def identifier
+    end
+
+    sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
+    # Returns a hash representation of this concept
+    def dump
+    end
+
+    # Generates a signature for this concept that can be used to determine
+    # if it has changed and requires regeneration of artifacts
+    sig { returns(String) }
+    def signature
+      # Generate a signature based on the resource's properties
+      digest = Digest::SHA1.new
+      digest.update(dump.to_json)
+      digest.hexdigest
+    end
+  end
+end

lib/forge/path_template.rb

@@ -0,0 +1,88 @@
+# typed: strict
+
+require_relative "concept"
+
+class Forge
+  # Allows defining a template for the file and path of the output of a
+  # synthesizer.
+  class PathTemplate
+    extend T::Sig
+
+    class BadSignatureError < StandardError
+    end
+
+    class MultipleFilesForConceptError < StandardError
+    end
+
+    sig { params(path: String, basename: String, extension: String).void }
+    def initialize(path:, basename:, extension:)
+      @path = path
+      @basename = basename
+      @extension = extension
+      @filename_regex = T.let(nil, T.nilable(Regexp))
+      @existing_file = T.let(nil, T.nilable(String))
+    end
+
+    sig { params(signature: String).returns(String) }
+    def filename(signature)
+      "#{basename}.#{signature}.#{extension}"
+    end
+
+    sig { params(signature: String).returns(String) }
+    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
+    end
+
+    private
+
+    sig { returns(T.nilable(String)) }
+    def find_existing_file
+      signatures =
+        Dir
+          .glob(glob)
+          .filter_map do |path|
+            match = path.match(filename_regex)
+            raise BadSignatureError, "Bad signature found: #{path}" unless match
+            match[1]
+          end
+
+      if signatures.size > 1
+        raise MultipleFilesForConceptError, "Multiple files found for #{glob}"
+      end
+      signatures.first
+    end
+
+    sig { returns(String) }
+    def glob
+      full_path("*").gsub(".", "\.")
+    end
+
+    sig { returns(Regexp) }
+    def filename_regex
+      @filename_regex ||= Regexp.new("#{basename}\.(\H+)\.#{extension}", "i")
+    end
+
+    sig { returns(String) }
+    attr_reader :path
+
+    sig { returns(String) }
+    attr_reader :basename
+
+    sig { returns(String) }
+    attr_reader :extension
+  end
+end

lib/resource_registry/synthesizer.rb lib/forge/synthesizer.rb

@@ -1,12 +1,16 @@
 # typed: strict
 
+require_relative "concept"
+require_relative "path_template"
+require_relative "artifact"
+
 # A `Synthesizer` can be used to synthesize source code
 # from a given resource.
 #
 # This enables defining capabilities that create static source files instead of
 # metaprogramming things at runtime. Synthesizers should be able to be applied
 # over a single resource, schema or verb.
-module ResourceRegistry
+class Forge
   module Synthesizer
     extend T::Sig
     extend T::Helpers
@@ -19,21 +23,24 @@ def name
 
     # Returns true if the synthesizer can synthesize an artifact for the given
     # concept.
-    sig do
-      abstract
-        .params(concept: ResourceRegistry::Forge::Concept)
-        .returns(T::Boolean)
-    end
+    # This should implement any checks to determine if the synthesizer can
+    # synthesize the given concept, for example, checking if the concept has
+    # appropriate capabilities.
+    sig { abstract.params(concept: Forge::Concept).returns(T::Boolean) }
     def synthesizes?(concept)
     end
 
     # Synthesizes an artifact for the given concept.
+    sig { abstract.params(concept: Forge::Concept).returns(Forge::Artifact) }
+    def synthesize(concept)
+    end
+
+    # Returns the template to create the path and filename of the output file
+    # for the given concept
     sig do
-      abstract
-        .params(concept: ResourceRegistry::Forge::Concept)
-        .returns(ResourceRegistry::Synthesizer::Artifact)
+      abstract.params(concept: Forge::Concept).returns(Forge::PathTemplate)
     end
-    def synthesize(concept)
+    def path_template(concept)
     end
   end
 end

lib/resource_registry/forge.rb

@@ -6,11 +6,13 @@
 require_relative "relationship"
 require_relative "verb"
 require_relative "../schema_registry/schema"
+require_relative "../forge/concept"
 
 module ResourceRegistry
   # The main class that represents a resource in the system.
   class Resource < T::Struct
     extend T::Sig
+    include Forge::Concept
 
     class VerbNotFound < StandardError
     end
@@ -47,7 +49,7 @@ def slug
       @slug ||= T.let(name.to_s.parameterize, T.nilable(String))
     end
 
-    sig { returns(Symbol) }
+    sig { override.returns(Symbol) }
     def identifier
       @identifier ||=
         T.let(
@@ -206,22 +208,20 @@ def verbs_except(except)
       verbs.values.filter { |v| except.exclude?(v.id) }
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def dump
       {
-        "identifier" => identifier,
-        "repository" => repository_raw,
-        "description" => description,
-        "relationships" => relationships.values.map(&:dump),
-        "capabilities" =>
+        identifier: identifier,
+        repository: repository_raw,
+        description: description,
+        relationships: relationships.values.map(&:dump),
+        capabilities:
           capabilities.values.map { |cap| CapabilityFactory.dump(cap) },
-        "schema" => schema.dump,
-        "verbs" =>
+        schema: schema.dump,
+        verbs:
           verbs
             .values
-            .each_with_object({}) do |verb, memo|
-              memo[verb.id.to_s] = verb.dump
-            end
+            .each_with_object({}) { |verb, memo| memo[verb.id] = verb.dump }
       }
     end