xccache 0.0.1a2 → 0.0.1a3

data/lib/xccache/spm/pkg/base.rb

@@ -1,15 +1,20 @@
 require "json"
-require "xccache/framework/slice"
-require "xccache/framework/xcframework"
+require "xccache/spm/xcframework/slice"
+require "xccache/spm/xcframework/xcframework"
+require "xccache/spm/xcframework/metadata"
 require "xccache/swift/sdk"
 
 module XCCache
   module SPM
     class Package
+      include Cacheable
+      cacheable :pkg_desc_of_target
+
       attr_reader :root_dir
 
       def initialize(options = {})
         @root_dir = Pathname(options[:root_dir] || ".").expand_path
+        @warn_if_not_direct_target = options.fetch(:warn_if_not_direct_target, true)
       end
 
       def build(options = {})
@@ -17,44 +22,50 @@ module XCCache
         targets = options.delete(:targets) || []
         raise GeneralError, "No targets were specified" if targets.empty?
 
-        targets.map { |t| t.split("/")[-1] }.each do |t|
-          UI.section("\n▶ Building target: #{t}".bold.magenta) do
+        targets.map { |t| t.split("/")[-1] }.each_with_index do |t, i|
+          UI.section("\n▶ Building target: #{t} (#{i + 1}/#{targets.count})".bold.magenta) do
             build_target(**options, target: t)
           rescue StandardError => e
             UI.error("Failed to build target: #{t}. Error: #{e}")
-            raise e unless config.ignore_build_errors?
+            raise e unless Config.instance.ignore_build_errors?
           end
         end
       end
 
-      def build_target(target: nil, sdk: nil, config: nil, out_dir: nil, **options)
-        target_pkg_desc = pkg_desc_of_target(target, skip_resolve: options[:skip_resolve])
+      def build_target(target: nil, sdks: nil, config: nil, out_dir: nil, **options)
+        target_pkg_desc = pkg_desc_of_target(target, skip_resolving_dependencies: options[:skip_resolving_dependencies])
         if target_pkg_desc.binary_targets.any? { |t| t.name == target }
           return UI.warn("Target #{target} is a binary target -> no need to build")
         end
 
-        sdks = (sdk || "iphonesimulator").split(",")
+        target = target_pkg_desc.get_target(target)
 
         out_dir = Pathname(out_dir || ".")
-        out_dir /= target if options[:checksum]
-        basename = options[:checksum] ? "#{target}-#{target_pkg_desc.checksum}.xcframework" : "#{target}.xcframework"
-
-        Framework::XCFramework.new(
-          name: target,
-          pkg_dir: root_dir,
-          config: config,
-          sdks: sdks,
-          path: out_dir / basename,
-          pkg_desc: target_pkg_desc,
-        ).create
+        out_dir /= target.name if options[:checksum]
+        basename = options[:checksum] ? "#{target.name}-#{target.checksum}" : target.name
+        basename += target.macro? ? ".macro" : ".xcframework"
+
+        Dir.create_tmpdir do |_tmpdir|
+          cls = target.macro? ? Macro : XCFramework
+          cls.new(
+            name: target.name,
+            pkg_dir: root_dir,
+            config: config,
+            sdks: sdks,
+            path: out_dir / basename,
+            tmpdir: Dir.create_tmpdir,
+            pkg_desc: target_pkg_desc,
+            library_evolution: options[:library_evolution],
+          ).build(**options)
+        end
       end
 
       def resolve(force: false)
         return if @resolved && !force
 
-        UI.info("Resolving package dependencies (package: #{root_dir.basename.to_s.dark})")
-        Sh.run("swift package resolve --package-path #{root_dir} 2>&1")
-        create_symlinks_to_local_pkgs
+        UI.section("Resolving package dependencies (package: #{root_dir.basename})", timing: true) do
+          Sh.run("swift package resolve --package-path #{root_dir} 2>&1")
+        end
         @resolved = true
       end
 
@@ -65,39 +76,32 @@ module XCCache
         raise GeneralError, "No Package.swift in #{root_dir}. Are you sure you're running on a package dir?"
       end
 
-      def pkg_desc_of_target(name, skip_resolve: false)
-        # TODO: Refactor this resolution logic
-        find_pkg_desc = proc do
-          # The current package contains the given target
-          return pkg_desc if pkg_desc.has_target?(name)
+      def pkg_desc_of_target(name, skip_resolving_dependencies: false)
+        # The current package contains the given target
+        return pkg_desc if pkg_desc.has_target?(name)
 
+        if @warn_if_not_direct_target
           UI.message(
             "#{name.yellow.dark} is not a direct target of package #{root_dir.basename.to_s.dark} " \
             "-> trigger from dependencies"
           )
-          # Otherwise, it's inside one of the dependencies. Need to resolve then find it
-          resolve unless skip_resolve
-          root_dir.glob(".build/checkouts/*").each do |dir|
-            desc = Description.in_dir(dir)
-            return desc if desc.has_target?(name)
-          end
-          raise GeneralError, "Cannot find package with the given target #{name}"
         end
-
-        @cache_pkg_desc_by_name ||= {}
-        @cache_pkg_desc_by_name[name] = find_pkg_desc.call unless @cache_pkg_desc_by_name.key?(name)
-        @cache_pkg_desc_by_name[name]
+        # Otherwise, it's inside one of the dependencies. Need to resolve then find it
+        resolve unless skip_resolving_dependencies
+
+        @descs ||= if Config.instance.in_installation?
+                   then Description.descs_in_metadata_dir[0]
+                   else
+                     Description.descs_in_dir(Pathname(".").expand_path)[0]
+                   end
+        desc = @descs.find { |d| d.has_target?(name) }
+        return desc unless desc.nil?
+        raise GeneralError, "Cannot find package with the given target #{name}"
       end
 
       def pkg_desc
         @pkg_desc ||= Description.in_dir(root_dir)
       end
-
-      def create_symlinks_to_local_pkgs
-        pkg_desc.dependencies.select(&:local?).each do |dep|
-          dep.path.symlink_to(root_dir / ".build/checkouts/#{dep.slug}")
-        end
-      end
     end
   end
 end

data/lib/xccache/spm/pkg/umbrella/build.rb

@@ -1,14 +1,14 @@
 module XCCache
   module SPM
     class Package
-      module UmbrellaBuilldMixin
+      module UmbrellaBuildMixin
         def build(options = {})
           to_build = targets_to_build(options)
           return UI.warn("Detected no targets to build among cache-missed targets") if to_build.empty?
 
           UI.info("-> Targets to build: #{to_build.to_s.bold}")
           super(options.merge(:targets => to_build))
-          sync_cachemap
+          sync_cachemap(sdks: options[:sdks])
         end
 
         def targets_to_build(options)

data/lib/xccache/spm/pkg/umbrella/cachemap.rb

@@ -2,27 +2,29 @@ module XCCache
   module SPM
     class Package
       module UmbrellaCachemapMixin
-        def sync_cachemap
-          UI.section("Syncing cachemap")
+        def sync_cachemap(sdks: [])
+          UI.section("Syncing cachemap (sdks: #{sdks.map(&:name)})")
           nodes, edges, parents = xccache_desc.traverse
-          cache_data = gen_cache_data(nodes, parents)
-          targets_data, deps_data = {}, {}
+          cache_data = gen_cache_data(nodes, parents, sdks)
+          targets_data, macros_data, deps_data = {}, {}, {}
           xccache_desc.targets.each do |agg_target|
-            targets_data[agg_target.name] = agg_target.direct_dependencies.flat_map do |d|
+            targets, macros = [], []
+            agg_target.direct_dependencies.each do |d|
+              all_hit = d.recursive_targets.all? { |t| cache_data[t] == :hit }
               # If any associated targets is missed -> use original product form
               # Otherwise, replace with recursive targets' binaries
-              deps_data[d.full_name] = d.recursive_targets.map(&:full_name)
-              if d.recursive_targets.all? { |t| cache_data[t] == :hit }
-                "#{d.full_name}.binary"
-              else
-                d.full_name
-              end
-            end.uniq.sort_by(&:downcase)
+              deps_data[d.full_name] = d.recursive_targets.map(&:xccache_id)
+              targets << (all_hit ? "#{d.full_name}.binary" : d.full_name)
+              macros += d.recursive_targets.select(&:macro?).map(&:full_name) if all_hit
+            end
+            targets_data[agg_target.name] = targets.uniq.sort_by(&:downcase)
+            macros_data[agg_target.name] = macros.uniq
           end
 
           config.cachemap.raw = {
             "manifest" => {
               "targets" => targets_data,
+              "macros" => macros_data,
               "deps" => deps_data,
             },
             "cache" => cache_data.transform_keys(&:full_name),
@@ -37,11 +39,11 @@ module XCCache
 
         private
 
-        def gen_cache_data(nodes, parents)
+        def gen_cache_data(nodes, parents, sdks)
           result = nodes.to_h do |node|
             res = if config.ignore?(node.full_name) then :ignored
                   else
-                    verify_binary?(node) ? :hit : :missed
+                    verify_binary?(node, sdks) ? :hit : :missed
                   end
             [node, res]
           end
@@ -56,35 +58,50 @@ module XCCache
             result[node] = :missed if result[node] == :hit
             to_visit += parents[node] if parents.key?(node)
           end
-          result
+          result.reject { |k, _| k.name.end_with?(".xccache") }
         end
 
-        def verify_binary?(target)
+        def verify_binary?(target, sdks)
           return true if target.binary?
 
-          bpath = binary_path(target.name)
-          bpath_with_checksum = binary_path(target.name, checksum: target.root.checksum)
-          # If checksum matches, create symlink from `A-abc123.xcframework` -> `A.framework`
+          bpath = binary_path(target.xccache_id)
+          bpath_with_checksum = binary_path(target.xccache_id, checksum: target.checksum, in_repo: true)
+
+          check = proc do
+            # For macro, we just need the tool binary to exist
+            # For regular targets, the xcframework must satisfy the sdk constraints (ie. containing all the slices)
+            next bpath_with_checksum.exist? if target.macro?
+
+            metadata = XCFramework::Metadata.new(bpath_with_checksum / "Info.plist")
+            expected_triples = sdks.map { |sdk| sdk.triple(without_vendor: true) }
+            missing_triples = expected_triples - metadata.triples
+            missing_triples.empty?
+          end
+
+          # If requirements are meet, create symlink `A-abc123.xcframework` -> `A.framework`
           # Otherwise, remove symlink `A.xcframework`
-          if bpath_with_checksum.exist?
+          if check.call
             bpath_with_checksum.symlink_to(bpath)
           elsif bpath.exist?
             bpath.rmtree
           end
-          bpath_with_checksum.exist?
+          bpath.exist?
         end
 
-        def binary_path(name, checksum: nil)
+        def binary_path(name, checksum: nil, in_repo: false)
           suffix = checksum.nil? ? "" : "-#{checksum}"
-          p = config.spm_binaries_frameworks_dir / File.basename(name, ".binary")
-          p / "#{p.basename}#{suffix}.xcframework"
+          ext = File.extname(name) == ".macro" ? ".macro" : ".xcframework"
+          binaries_dir = in_repo ? config.spm_repo_dir : config.spm_binaries_dir
+          p = binaries_dir / File.basename(name, ".*")
+          p / "#{p.basename}#{suffix}#{ext}"
         end
 
         def target_to_cytoscape_node(x, cache_data)
           h = { :id => x.full_name, :cache => cache_data[x] }
-          h[:type] = "agg" if x.name.end_with?(".xccache")
-          h[:checksum] = x.root.checksum
-          h[:binary] = binary_path(x.name) if cache_data[x] == :hit
+          h[:type] = if x.name.end_with?(".xccache") then "agg"
+                     elsif x.macro? then "macro" end
+          h[:checksum] = x.checksum
+          h[:binary] = binary_path(x.xccache_id) if cache_data[x] == :hit
           h
         end
       end

data/lib/xccache/spm/pkg/umbrella/descs.rb

@@ -3,19 +3,8 @@ module XCCache
     class Package
       module UmbrellaDescsMixin
         def gen_metadata
-          UI.section("Generating metadata of packages") do
-            dirs = [root_dir] + root_dir.glob(".build/checkouts/*").reject { |p| p.glob("Package*.swift").empty? }
-            dirs.each do |dir|
-              desc = Description.in_dir(dir, save_to_dir: config.spm_metadata_dir)
-              next if desc.nil?
-
-              desc.retrieve_pkg_desc = proc { |name| @descs_by_name[name] }
-              desc.save
-              desc.save(to: desc.path.parent / "#{desc.name}.json") if desc.name != dir.basename.to_s
-              @descs << desc
-              @descs_by_name[desc.name] = desc
-              @descs_by_name[dir.basename.to_s] = desc
-            end
+          UI.section("Generating metadata of packages", timing: true) do
+            @descs, @descs_by_name = Description.descs_in_dir(root_dir, save_to_dir: config.spm_metadata_dir)
           end
         end
 

data/lib/xccache/spm/pkg/umbrella/manifest.rb

@@ -3,7 +3,7 @@ module XCCache
     class Package
       module UmbrellaManifestMixin
         def write_manifest(no_cache: false)
-          UI.info("Writing Package.swift (package: #{root_dir.basename.to_s.dark})")
+          UI.info("Writing Package.swift (package: #{root_dir.basename})")
           Template.new("umbrella.Package.swift").render(
             {
               :timestamp => Time.new.strftime("%F %T"),

data/lib/xccache/spm/pkg/umbrella/viz.rb

@@ -13,15 +13,15 @@ module XCCache
             p.to_s.start_with?(root_dir.to_s) ? p.relative_path_from(root_dir).to_s : p.to_s
           end
 
-          UI.message("Cachemap visualization: #{html_path}")
+          UI.info("Cachemap visualization: #{html_path}")
           Template.new("cachemap.html").render(
             {
               :root_dir => root_dir.to_s,
               :root_dir_short => root_dir.basename.to_s,
               :lockfile_path => config.lockfile.path.to_s,
               :lockfile_path_short => to_relative.call(config.lockfile.path),
-              :binaries_dir => config.spm_binaries_frameworks_dir.to_s,
-              :binaries_dir_short => to_relative.call(config.spm_binaries_frameworks_dir),
+              :binaries_dir => config.spm_binaries_dir.to_s,
+              :binaries_dir_short => to_relative.call(config.spm_binaries_dir),
               :desc_hit => stats[:hit],
               :desc_missed => stats[:missed],
               :desc_ignored => stats[:ignored],

data/lib/xccache/spm/pkg/umbrella/xcconfigs.rb

@@ -0,0 +1,31 @@
+module XCCache
+  module SPM
+    class Package
+      module UmbrellaXCConfigsMixin
+        def gen_xcconfigs
+          UI.section("Generating xcconfigs") do
+            macros_config_by_targets.each do |target, hash|
+              xcconfig_path = config.spm_xcconfig_dir / "#{target}.xcconfig"
+              UI.message("XCConfig of target #{target} at: #{xcconfig_path}")
+              Xcodeproj::Config.new(hash).save_as(xcconfig_path)
+            end
+          end
+        end
+
+        private
+
+        def macros_config_by_targets
+          config.cachemap.manifest_data["macros"].to_h do |target, macros|
+            swift_flags = macros.map do |m|
+              basename = File.basename(m, ".*")
+              binary_path = config.spm_binaries_dir / basename / "#{basename}.macro"
+              "-load-plugin-executable #{binary_path}##{basename}"
+            end
+            hash = { "OTHER_SWIFT_FLAGS" => "$(inherited) #{swift_flags.join(' ')}" }
+            [File.basename(target, ".*"), hash]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xccache/spm/pkg/umbrella.rb

@@ -12,9 +12,10 @@ module XCCache
         include Config::Mixin
         include UmbrellaCachemapMixin
         include UmbrellaDescsMixin
-        include UmbrellaBuilldMixin
+        include UmbrellaBuildMixin
         include UmbrellaManifestMixin
         include UmbrellaVizMixin
+        include UmbrellaXCConfigsMixin
 
         def initialize(options = {})
           super
@@ -25,12 +26,13 @@ module XCCache
 
         def prepare(options = {})
           create
-          resolve unless options[:skip_resolve]
-          create_symlinks
+          resolve unless options[:skip_resolving_dependencies]
+          create_symlinks_for_convenience
+          create_symlinks_to_local_pkgs
           gen_metadata
           resolve_recursive_dependencies
           create_symlinks_to_artifacts
-          sync_cachemap
+          sync_cachemap(sdks: options[:sdks])
         end
 
         def resolve_recursive_dependencies
@@ -51,22 +53,30 @@ module XCCache
           end
         end
 
-        def create_symlinks
+        def create_symlinks_for_convenience
           # Symlinks for convenience
           (root_dir / "binaries").symlink_to(root_dir.parent / "binaries")
           (root_dir / ".build").symlink_to(root_dir.parent / ".build")
           (root_dir / ".build/checkouts").symlink_to(root_dir.parent / "checkouts")
         end
 
+        def create_symlinks_to_local_pkgs
+          pkg_desc.dependencies.select(&:local?).each do |dep|
+            # For metadata generation
+            dep.path.symlink_to(root_dir / ".build/checkouts/#{dep.slug}")
+            # For convenience, synced group under `xccache.config` group in xcodeproj
+            dep.path.symlink_to(Config.instance.spm_local_pkgs_dir / dep.slug)
+          end
+        end
+
         def create_symlinks_to_artifacts
-          # Clean up broken symlinks
-          config.spm_binaries_frameworks_dir.glob("*/*.xcframework").each do |p|
-            p.rmtree if p.symlink? && !p.readlink.exist?
+          # Clean up symlinks beforehand
+          config.spm_binaries_dir.glob("*/*.{xcframework,macro}").each do |p|
+            p.rmtree if p.symlink?
           end
 
-          UI.message("Creating symlinks to binary artifacts of targets: #{binary_targets.map(&:full_name).to_s.dark}")
           binary_targets.each do |target|
-            dst_path = config.spm_binaries_frameworks_dir / target.name / "#{target.name}.xcframework"
+            dst_path = config.spm_binaries_dir / target.name / "#{target.name}.xcframework"
             # For local xcframework, just symlink to the path
             # Zip frameworks (either of local or remote pkgs) are unzipped in the build artifacts
             target.local_binary_path.symlink_to(dst_path) if target.local_binary_path&.extname == ".xcframework"

data/lib/xccache/spm/xcframework/metadata.rb

@@ -0,0 +1,41 @@
+require "xccache/core/syntax/plist"
+
+module XCCache
+  module SPM
+    class XCFramework
+      class Metadata < PlistRepresentable
+        class Library < Hash
+          def id
+            self["LibraryIdentifier"]
+          end
+
+          def platform
+            self["SupportedPlatform"]
+          end
+
+          def archs
+            self["SupportedArchitectures"]
+          end
+
+          def simulator?
+            self["SupportedPlatformVariant"] == "simulator"
+          end
+
+          def triples
+            @triples ||= archs.map do |arch|
+              simulator? ? "#{arch}-#{platform}-simulator" : "#{arch}-#{platform}"
+            end
+          end
+        end
+
+        def available_libraries
+          @available_libraries ||= raw.fetch("AvailableLibraries", []).map { |h| Library.new.merge(h) }
+        end
+
+        def triples
+          @triples ||= available_libraries.flat_map(&:triples)
+        end
+      end
+    end
+  end
+end

data/lib/xccache/{framework → spm/xcframework}/slice.rb

@@ -1,34 +1,11 @@
 require "xccache/utils/template"
 
 module XCCache
-  class Framework
-    class Slice
-      attr_reader :name, :module_name, :pkg_dir, :pkg_desc, :sdk, :config, :path, :tmpdir
-
-      def initialize(options = {})
-        @name = options[:name]
-        @module_name = @name.c99extidentifier
-        @pkg_dir = Pathname(options[:pkg_dir] || ".").expand_path
-        @pkg_desc = options[:pkg_desc]
-        @sdk = options[:sdk]
-        @config = options[:config] || "debug"
-        @path = options[:path]
-        @tmpdir = options[:tmpdir]
-      end
-
-      def build
+  module SPM
+    class FrameworkSlice < Buildable
+      def build(_options = {})
         UI.section("Building slice: #{name} (#{config}, #{sdk})".bold) do
-          cmd = ["swift", "build"] + swift_build_args
-          cmd << "--package-path" << pkg_dir
-          cmd << "--target" << name
-          cmd << "--sdk" << sdk.sdk_path
-          # Workaround for swiftinterface emission
-          # https://github.com/swiftlang/swift/issues/64669#issuecomment-1535335601
-          cmd << "-Xswiftc" << "-enable-library-evolution"
-          cmd << "-Xswiftc" << "-alias-module-names-in-module-interface"
-          cmd << "-Xswiftc" << "-emit-module-interface"
-          cmd << "-Xswiftc" << "-no-verify-emitted-module-interface"
-          Sh.run(cmd, suppress_err: /(dependency '.*' is not used by any target|unable to create symbolic link)/)
+          swift_build
           create_framework
         end
       end
@@ -102,36 +79,59 @@ module XCCache
       end
 
       def create_headers
-        Dir.prepare(path / "Headers")
-        copy_headers if use_clang?
+        copy_headers
       end
 
       def create_modules
-        Dir.prepare(path / "Modules")
-        return copy_swiftmodules unless use_clang?
+        copy_swiftmodules unless use_clang?
 
         UI.message("Creating framework modulemap")
         Template.new("framework.modulemap").render(
-          { :module_name => module_name },
-          save_to: path / "Modules" / "module.modulemap"
+          { :module_name => module_name, :target => name },
+          save_to: modules_dir / "module.modulemap"
         )
       end
 
       def copy_headers
         UI.message("Copying headers")
-        framework_headers_path = path / "Headers"
-        umbrella_header_content =
-          pkg_target
-          .header_paths
-          .map { |p| p.copy(to_dir: framework_headers_path) }
-          .map { |p| "#include \"#{p.basename}\"" }
-          .join("\n")
-        (framework_headers_path / "#{module_name}-umbrella.h").write(umbrella_header_content)
+        swift_header_paths = products_dir.glob("#{module_name}.build/*-Swift.h")
+        paths = swift_header_paths + pkg_target.header_paths
+        paths.each { |p| process_header(p) }
+
+        umbrella_header_content = paths.map { |p| "#include <#{module_name}/#{p.basename}>" }.join("\n")
+        (headers_dir / "#{name}-umbrella.h").write(umbrella_header_content)
+      end
+
+      def process_header(path)
+        handle_angle_bracket_import = proc do |statement, header|
+          next statement if header.include?("/")
+
+          # NOTE: If importing a header with flat angle-bracket style (ex. `#import <foo.h>`)
+          # The header `foo.h` may belong to a dependency's headers.
+          # When packaging into xcframework, `#import <foo.h>` no longer works because `foo.h`
+          # coz it's not visible within the framework's headers
+          # -> We need to explicitly specify the module it belongs to, ex. `#import <foo/foo.h>`
+          targets = [pkg_target] + pkg_target.recursive_targets
+          target = targets.find { |t| t.header_paths.any? { |p| p.basename.to_s == header } }
+          next statement if target.nil?
+
+          corrected_statement = statement.sub("<#{header}>", "<#{target.module_name}/#{header}>")
+          <<~CONTENT
+            // -------------------------------------------------------------------------------------------------
+            // NOTE: This import was corrected by xccache, from flat angle-bracket to nested angle-bracket style
+            // Original: `#{statement}`
+            #{corrected_statement}
+            // -------------------------------------------------------------------------------------------------
+          CONTENT
+        end
+
+        content = path.read.gsub(/^ *#import <(.+)>/) { |m| handle_angle_bracket_import.call(m, $1) }
+        (headers_dir / path.basename).write(content)
       end
 
       def copy_swiftmodules
         UI.message("Copying swiftmodules")
-        swiftmodule_dir = Dir.prepare("#{path}/Modules/#{module_name}.swiftmodule")
+        swiftmodule_dir = Dir.prepare("#{modules_dir}/#{module_name}.swiftmodule")
         swiftinterfaces = products_dir.glob("#{module_name}.build/#{module_name}.swiftinterface")
         to_copy = products_dir.glob("Modules/#{module_name}.*") + swiftinterfaces
         to_copy.each do |p|
@@ -160,23 +160,20 @@ module XCCache
         @products_dir ||= pkg_dir / ".build" / sdk.triple / config
       end
 
-      def swift_build_args
-        [
-          "--configuration", config,
-          "--triple", sdk.triple,
-        ]
-      end
-
       def use_clang?
         pkg_target.use_clang?
       end
 
-      def pkg_target
-        @pkg_target ||= pkg_desc.get_target(name)
+      def resource_bundle_product_path
+        @resource_bundle_product_path ||= products_dir / pkg_target.resource_bundle_name
       end
 
-      def resource_bundle_product_path
-        @resource_bundle_product_path ||= products_dir / pkg_target.bundle_name
+      def headers_dir
+        @headers_dir ||= Dir.prepare(path / "Headers")
+      end
+
+      def modules_dir
+        @modules_dir ||= Dir.prepare(path / "Modules")
       end
     end
   end