foobar_templates 2.0.1.rc1 → 2.0.1.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 247c1ea143d5bffcb645aa6ee4ce0793a8962869b100e268c424697d77b8b4c8
-  data.tar.gz: c6fe7ccc5771db07b24c61d8d640f3516f2b73308d1937334df69069139658cd
+  metadata.gz: f6f830e123079c5b60a6cd7f799df40f0615b6326565814e837029ea6a8d69e9
+  data.tar.gz: 8d19d2bad9ee276d489657f9de11ef0ac8e9929a92d7fa08d95b2f9e609bc9d4
 SHA512:
-  metadata.gz: 78e4608ba4ec94b0a0271f7753ae5b65d79cbbe6dec0a36d42cce040bdbd78353ba872158abce356cb82c0e98e1198eedf28becdc4956d36be0b3750821151db
-  data.tar.gz: fb918a1c50461ed3bc66e0c3c54fc1f0ba50ae0f0bcd04d381810a7009563fbfaec5142e3c111329c2c1f69b44df31c30b17f447ea6de45c0afa26527cb05d76
+  metadata.gz: 2e2abe9daa3749abab39f10fbb110b8262541fd2ebba6f74d4c6d0bf85fe97d3e05a6745f05cb05fbb27db532c2c2d99945afe028e90dba066335648669ad998
+  data.tar.gz: df73ec40e11c12ac8316ab4c6105ac0d9ea895f2ca049b6b676b44660d7656df8041411ef38775d30e98f1d5a6909c2e4cb70e0210769b94d69eebfa6ffa7025

data/bin/foobar_templates

@@ -29,6 +29,10 @@ parser = OptionParser.new do |opts|
     exit
   end
 
+  opts.on("-p", "--performance", "Show performance metrics for template generation") do
+    options[:performance] = true
+  end
+
   opts.on("--install-public-templates", "Install public templates") do
     FoobarTemplates.install_public_templates
     exit

data/changelog

@@ -1,5 +1,6 @@
 ** Unreleased **
   - Rename: project renamed from `bundlegem` to `foobar_templates`. Module is now `FoobarTemplates`, executable is `foobar_templates`, per-template config file is `foobar.yml`, and user config/templates live under `~/.foobar/`. No backward-compatibility shims.
+  - Bugfix: fixes `Arg list too long` crash when generating from templates containing many gitignored files (e.g. node_modules); ignored directories are now pruned during a breadth-first traversal and path checks are streamed to `git check-ignore` via NUL-delimited stdin instead of argv.
 
 ** Planned 0.2.x **
   - Feature: templates can declare a `name_validation:` block in bundlegem.yml with two optional keys: `reserved_names` (exact-match denylist) and `regex_validator` (a Ruby regex the project name must match). Validation runs after the built-in regex check and before any files are written. All checks happen in pure Ruby — no shell, no cross-platform concerns.

data/config/config

@@ -3,6 +3,6 @@
 default_template: cli_gem
 public_templates: https://github.com/TheNotary/template-builtins
 registry_domain: null
-repo_domain: null
-k8s_domain: null
+repo_domain: null     # github.com
+k8s_domain: null      # k8s.example.com
 always_perform_git_init: false

data/lib/foobar_templates/cli/template_generator.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 require 'yaml'
 require 'open3'
-require 'shellwords'
 require 'set'
 
 $TRACE = false
@@ -24,53 +23,67 @@ module FoobarTemplates::CLI
     end
 
     def config
-      @config ||= build_interpolation_config
+      @config ||= time_it("build_interpolation_config") { build_interpolation_config }
     end
 
     def run
-      puts "Beginning run" if $TRACE
-      raise_project_with_that_name_already_exists! if File.exist?(target)
+      time_it("TOTAL run") do
+        puts "Beginning run" if $TRACE
+        raise_project_with_that_name_already_exists! if File.exist?(target)
 
-      puts "ensure_safe_project_name" if $TRACE
-      ensure_safe_project_name(name, config[:constant_array])
+        puts "ensure_safe_project_name" if $TRACE
+        time_it("ensure_safe_project_name") do
+          ensure_safe_project_name(name, config[:constant_array])
+        end
 
-      puts "run_name_validation" if $TRACE
-      run_name_validation
+        puts "run_name_validation" if $TRACE
+        time_it("run_name_validation") { run_name_validation }
 
-      template_src = match_template_src
+        template_src = time_it("match_template_src") { match_template_src }
 
-      puts "dynamically_generate_template_directories" if $TRACE
-      time_it("dynamically_generate_template_directories") do
-        @template_directories = dynamically_generate_template_directories
-      end
+        puts "dynamically_generate_template_directories" if $TRACE
+        @template_directories = time_it("dynamically_generate_template_directories") do
+          dynamically_generate_template_directories
+        end
 
-      puts "dynamically_generate_templates_files" if $TRACE
-      templates = dynamically_generate_templates_files
+        puts "dynamically_generate_templates_files" if $TRACE
+        templates = time_it("dynamically_generate_templates_files") do
+          dynamically_generate_templates_files
+        end
 
-      puts "Creating new project folder '#{name}'\n\n"
-      create_template_directories(@template_directories, target)
+        puts "Creating new project folder '#{name}'\n\n"
+        time_it("create_template_directories") do
+          create_template_directories(@template_directories, target)
+        end
 
-      templates.each do |src, dst|
-        template("#{template_src}/#{src}", target.join(dst), config)
-      end
+        time_it("write_template_files") do
+          templates.each do |src, dst|
+            template("#{template_src}/#{src}", target.join(dst), config)
+          end
+        end
 
-      Dir.chdir(target) do
-        if @configurator.always_perform_git_init || !inside_git_work_tree?
-          `git init`
+        time_it("git_init_and_add") do
+          Dir.chdir(target) do
+            if @configurator.always_perform_git_init || !inside_git_work_tree?
+              `git init`
+            end
+            `git add .`
+          end
         end
-        `git add .`
-      end
 
-      if @tconf[:bootstrap_command]
-        puts "Executing bootstrap_command"
-        cmd = safe_gsub_template_variables(@tconf[:bootstrap_command])
-        puts cmd
-        Dir.chdir(target) do
-          `#{cmd}`
+        if @tconf[:bootstrap_command]
+          puts "Executing bootstrap_command"
+          cmd = safe_gsub_template_variables(@tconf[:bootstrap_command])
+          puts cmd
+          time_it("bootstrap_command") do
+            Dir.chdir(target) do
+              `#{cmd}`
+            end
+          end
         end
-      end
 
-      puts "\nComplete."
+        puts "\nComplete."
+      end
     end
 
     def build_interpolation_config
@@ -85,7 +98,9 @@ module FoobarTemplates::CLI
       git_user_email = `git config user.email`.chomp
 
       # Resolve domain values from ~/.foobar/config, prompting if needed
-      required_domains = scan_template_for_required_domains
+      required_domains = time_it("scan_template_for_required_domains") do
+        scan_template_for_required_domains
+      end
       prompt_for_missing_domains(required_domains)
 
       registry_domain = @configurator.domain('registry_domain')
@@ -271,39 +286,69 @@ module FoobarTemplates::CLI
 
     # Returns a hash of source directory names and their destination mappings
     def dynamically_generate_template_directories
-      template_dirs = Dir.glob("#{@template_src}/**/*", File::FNM_DOTMATCH).filter_map do |f|
-        base_path = f[@template_src.length+1..-1]
-        next if base_path.start_with?(".git" + File::SEPARATOR) || base_path == ".git"
-        next if f == "#{@template_src}/." || f == "#{@template_src}/.."
-        next unless File.directory?(f)
-        # next if ignored_by_git?(@template_src, base_path)
+      template_relative_paths.each_with_object({}) do |rel, dirs|
+        next unless File.directory?(File.join(@template_src, rel))
 
-        [base_path, substitute_template_values(base_path)]
-      end.to_h
-      filter_ignored_files!(@template_src, template_dirs)
-
-      template_dirs
+        dirs[rel] = substitute_template_values(rel)
+      end
     end
 
     # Figures out the translation between all template files and their
     # destination names
     def dynamically_generate_templates_files
-      template_files = Dir.glob("#{@template_src}/**/*", File::FNM_DOTMATCH).filter_map do |f|
-        base_path = f[@template_src.length+1..-1]
-        next if base_path.nil?
-        next if base_path.start_with?(".git" + File::SEPARATOR) || base_path == ".git"
-        next if base_path == "foobar.yml"
-        next unless File.file?(f)
+      template_files = template_relative_paths.each_with_object({}) do |rel, files|
+        next if rel == "foobar.yml"
+        next unless File.file?(File.join(@template_src, rel))
 
-        [base_path, substitute_template_values(base_path)]
-      end.to_h
+        files[rel] = substitute_template_values(rel)
+      end
 
       raise_no_files_in_template_error! if template_files.empty?
-      filter_ignored_files!(@template_src, template_files)
 
       return template_files
     end
 
+    # Enumerates every relative path under the template source, skipping the
+    # .git directory and any gitignored paths. Ignored directories are pruned
+    # during traversal so their (potentially huge) contents are never walked.
+    def template_relative_paths
+      @template_relative_paths ||= time_it("collect_non_ignored_paths") do
+        collect_non_ignored_paths(@template_src)
+      end
+    end
+
+    # Breadth-first walk that prunes ignored directories. One batched
+    # `git check-ignore` call is made per directory depth level, so we never
+    # descend into (or enumerate) an ignored subtree such as node_modules.
+    def collect_non_ignored_paths(root)
+      results = []
+      frontier = [nil] # relative dirs to scan at the current level; nil == root
+
+      until frontier.empty?
+        level_children = []
+        frontier.each do |rel_dir|
+          abs_dir = rel_dir ? File.join(root, rel_dir) : root
+          Dir.children(abs_dir).each do |name|
+            next if name == ".git"
+
+            level_children << (rel_dir ? File.join(rel_dir, name) : name)
+          end
+        end
+        break if level_children.empty?
+
+        ignored = ignored_paths(root, level_children)
+        next_frontier = []
+        level_children.each do |rel|
+          next if ignored.include?(rel)
+
+          results << rel
+          next_frontier << rel if File.directory?(File.join(root, rel))
+        end
+        frontier = next_frontier
+      end
+
+      results
+    end
 
     # Applies literal foo-bar variant substitutions to path strings
     def substitute_template_values(path_str)
@@ -351,12 +396,19 @@ module FoobarTemplates::CLI
       chunk.nil? || chunk.include?("\x00")
     end
 
-    def filter_ignored_files!(repo_root, path_hash)
-      cmd = "git -C #{repo_root} check-ignore #{Shellwords.join(path_hash.keys)}"
-      stdout, _, status = Open3.capture3(cmd)
-      filter_these_paths = stdout.split
-
-      path_hash.delete_if { |key, _| filter_these_paths.include?(key) }
+    # Returns the subset of the given relative paths that git considers ignored.
+    # Paths are streamed via NUL-delimited stdin rather than argv to avoid the
+    # OS ARG_MAX limit ("Arg list too long") and to handle paths containing
+    # spaces or newlines. Returns an empty set when root is not a git repo.
+    def ignored_paths(root, rel_paths)
+      return Set.new if rel_paths.empty?
+
+      stdin_data = rel_paths.join("\x00")
+      stdout, _, _status = Open3.capture3(
+        "git", "-C", root.to_s, "check-ignore", "-z", "--stdin",
+        stdin_data: stdin_data
+      )
+      stdout.split("\x00").to_set
     end
 
     def create_template_directories(template_directories, target)
@@ -442,11 +494,18 @@ Exiting...
     end
 
     def time_it(label = nil)
+      return yield unless performance?
+
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      yield
+      result = yield
       end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       elapsed_ms = ((end_time - start_time) * 1000).round(2)
       puts "#{label || 'Elapsed'}: #{elapsed_ms} ms"
+      result
+    end
+
+    def performance?
+      @options[:performance]
     end
 
     # This checks to see that the gem_name is a valid ruby gem name and will 'work'

data/lib/foobar_templates/version.rb

@@ -1,3 +1,3 @@
 module FoobarTemplates
-  VERSION = "2.0.1.rc1"
+  VERSION = "2.0.1.rc3"
 end

data/spec/foobar_templates_spec.rb

@@ -128,6 +128,26 @@ describe FoobarTemplates do
     expect(src_dst_map['simple_dir']).to eq 'simple_dir'
   end
 
+  it "collect_non_ignored_paths walks files but prunes gitignored directories" do
+    template_dir = create_user_defined_template("testing", "template-user-supplied")
+    options = { bin: false, ext: false, coc:  false, template: "template-user-supplied" }
+    my_gem = FoobarTemplates::CLI::TemplateGenerator.new(options, "good-dog")
+
+    File.write("#{template_dir}/.gitignore", "node_modules/\n")
+    File.write("#{template_dir}/README.md", "Hello")
+    FileUtils.mkdir_p("#{template_dir}/src")
+    File.write("#{template_dir}/src/main.rb", "puts 1")
+    FileUtils.mkdir_p("#{template_dir}/node_modules/big_pkg")
+    File.write("#{template_dir}/node_modules/big_pkg/index.js", "ignored")
+    `git init #{template_dir}`
+
+    paths = my_gem.send('collect_non_ignored_paths', template_dir)
+
+    expect(paths).to include("README.md", "src", "src/main.rb")
+    expect(paths).not_to include("node_modules")
+    expect(paths.grep(/node_modules/)).to be_empty
+  end
+
   it "returns the expected interpolated string when substitute_template_values is called" do
     options = { bin: false, ext: false, coc:  false, template: "test_template" }
     gem_name = "good-dog"
@@ -173,6 +193,26 @@ describe FoobarTemplates do
     expect(File).not_to exist "#{@dst_dir}/#{gem_name}/node_modules"
   end
 
+  it "handles templates with a large number of gitignored files without overflowing the arg list" do
+    template_dir = create_user_defined_template("testing", "template-user-supplied")
+    options = { bin: false, ext: false, coc:  false, template: "template-user-supplied" }
+    gem_name = "good-dog"
+
+    File.write("#{template_dir}/.gitignore", "node_modules/")
+    File.write("#{template_dir}/README.md", "Hello")
+    FileUtils.mkdir("#{template_dir}/node_modules")
+    # Enough files to blow past ARG_MAX if paths were passed as argv.
+    5000.times { |i| File.write("#{template_dir}/node_modules/file_#{i}.rb", "ignored #{i}") }
+    `git init #{template_dir}`
+
+    capture_stdout do 
+      FoobarTemplates.generate_template(options, gem_name)
+    end
+
+    expect(File).to exist "#{@dst_dir}/#{gem_name}/README.md"
+    expect(File).not_to exist "#{@dst_dir}/#{gem_name}/node_modules"
+  end
+
   it "executes the bootstrap_command if supplied" do
     template_dir = create_user_defined_template("testing", "template-user-supplied")
     options = { bin: false, ext: false, coc:  false, template: "template-user-supplied" }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobar_templates
 version: !ruby/object:Gem::Version
-  version: 2.0.1.rc1
+  version: 2.0.1.rc3
 platform: ruby
 authors:
 - TheNotary
 bindir: bin
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -130,9 +130,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/TheNotary/foobar_templates/issues
-  changelog_uri: https://github.com/TheNotary/foobar_templates/releases/tag/v2.0.1.rc1
+  changelog_uri: https://github.com/TheNotary/foobar_templates/releases/tag/v2.0.1.rc3
   documentation_uri: https://github.com/TheNotary/foobar_templates
-  source_code_uri: https://github.com/TheNotary/foobar_templates/tree/v2.0.1.rc1
+  source_code_uri: https://github.com/TheNotary/foobar_templates/tree/v2.0.1.rc3
 rdoc_options: []
 require_paths:
 - lib
@@ -147,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: This gem makes more gems!
 test_files: