foobar_templates 2.0.0

data/config/config

@@ -0,0 +1,8 @@
+# Comments made to this file will not be preserved
+---
+default_template: cli_gem
+public_templates: https://github.com/TheNotary/template-builtins
+registry_domain: null
+repo_domain: null
+k8s_domain: null
+always_perform_git_init: false

data/foobar_templates.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'foobar_templates/version'
+
+version = FoobarTemplates::VERSION
+
+Gem::Specification.new do |s|
+  s.name          = "foobar_templates"
+  s.version       = version
+  s.authors       = ["TheNotary"]
+  s.email         = ["no@mail.plz"]
+  s.summary       = %q{This gem makes more gems!}
+  s.description   = %q{ This is a gem for making more gems!  I know!  It's like asking a genie for more wishes but it actually works!}
+  s.homepage      = "https://github.com/thenotary/foobar_templates"
+  s.license       = "MIT"
+  s.required_ruby_version = '>= 3.0'
+
+  s.metadata["bug_tracker_uri"] = "https://github.com/TheNotary/foobar_templates/issues"
+  s.metadata["changelog_uri"] = "https://github.com/TheNotary/foobar_templates/releases/tag/v#{version}"
+  s.metadata["documentation_uri"] = "https://github.com/TheNotary/foobar_templates"
+  s.metadata["source_code_uri"] = "https://github.com/TheNotary/foobar_templates/tree/v#{version}"
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake", "~> 13.2"
+  s.add_development_dependency "rdoc", "~> 7.0"
+  s.add_development_dependency "rspec", "~> 3.13"
+  s.add_development_dependency "pry", "~> 0.16"
+end

data/lib/foobar_templates/cli/cheat_sheet.rb

@@ -0,0 +1,12 @@
+module FoobarTemplates::CLI
+  module CheatSheet
+    class << self
+
+      def go
+        gem_root = File.expand_path("../../../..", __FILE__)
+        File.read("#{gem_root}/spec/data/variable_manifest_test.rb").lines[3..-1].join
+      end
+
+    end
+  end
+end

data/lib/foobar_templates/cli/cli.rb

@@ -0,0 +1,3 @@
+require 'foobar_templates/cli/dir_to_template'
+require 'foobar_templates/cli/cheat_sheet'
+require 'foobar_templates/cli/setup_personal_templates_repo'

data/lib/foobar_templates/cli/dir_to_template.rb

@@ -0,0 +1,120 @@
+require 'find'
+require 'fileutils'
+require 'open3'
+require 'shellwords'
+
+
+module FoobarTemplates::CLI
+  module DirToTemplate
+    NO_PERSONAL_REPO_MSG = "Unable to convert to template, no personal templates repo exists.  Run `foobar_templates --setup-personal-templates` to get that setup.".freeze
+
+    class << self
+
+      def go(input: $stdin, output: $stdout)
+        personal_dir = FoobarTemplates::CLI::SetupPersonalTemplatesRepo.personal_templates_dir
+        if personal_dir.nil? || !File.directory?(personal_dir)
+          output.puts NO_PERSONAL_REPO_MSG
+          raise FoobarTemplates::CLIError
+        end
+
+        validate_inside_git_repo!(output: output)
+
+        project_name = File.basename(Dir.pwd)
+        default_category = read_existing_category(Dir.pwd) || "misc"
+
+        template_folder_name = prompt(input, output, "Template folder name", project_name)
+        validate_folder_name!(template_folder_name, output: output)
+
+        category = prompt(input, output, "Category", default_category)
+
+        dest = File.join(personal_dir, template_folder_name)
+
+        if File.exist?(dest)
+          output.puts "Error: a template already exists at #{dest}.  Remove it or rename your project before re-running."
+          raise FoobarTemplates::CLIError
+        end
+
+        copy_tracked_files_to(dest)
+        write_foobar_yml(dest, category)
+
+        files_changed = Dir.chdir(dest) do
+          FoobarTemplates::Core::DirToTemplate.🧙🪄! Find.find('.'), template_name: project_name
+        end
+
+        output.puts "Template created at: #{dest}"
+        output.puts "Tip: review the new template directory and remove any files that aren't helpful as a starting point (build artifacts, secrets, lockfiles, large fixtures, etc.)."
+        files_changed
+      end
+
+      private
+
+      def validate_inside_git_repo!(output: $stdout)
+        _stdout, _stderr, status = Open3.capture3("git rev-parse --is-inside-work-tree")
+        return if status.success?
+        output.puts "Error: --copy-to-templates must be run from within a git repository (it uses `git ls-files` to choose what to copy)."
+        raise FoobarTemplates::CLIError
+      end
+
+      def copy_tracked_files_to(dest)
+        # -c: cached/tracked, -o: untracked, --exclude-standard: respect .gitignore
+        # This naturally excludes .git/ and gitignored files while keeping .gitignore.
+        listing, _stderr, status = Open3.capture3("git ls-files -co --exclude-standard -z")
+        if !status.success?
+          $stderr.puts "Error: failed to enumerate files via `git ls-files`."
+          raise FoobarTemplates::CLIError
+        end
+
+        FileUtils.mkdir_p(dest)
+        listing.split("\0").each do |rel_path|
+          next if rel_path.empty?
+          src = rel_path
+          next unless File.file?(src) # skip submodule pointers, deleted files, etc.
+          target = File.join(dest, rel_path)
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.cp(src, target)
+        end
+      end
+
+      def ensure_foobar_yml(dest)
+        path = File.join(dest, "foobar.yml")
+        File.write(path, "category: misc\n") unless File.exist?(path)
+      end
+
+      def write_foobar_yml(dest, category)
+        path = File.join(dest, "foobar.yml")
+        if File.exist?(path)
+          contents = File.read(path)
+          if contents =~ /^category:.*$/
+            contents = contents.sub(/^category:.*$/, "category: #{category}")
+          else
+            contents = "category: #{category}\n" + contents
+          end
+          File.write(path, contents)
+        else
+          File.write(path, "category: #{category}\n")
+        end
+      end
+
+      def read_existing_category(dir)
+        path = File.join(dir, "foobar.yml")
+        return nil unless File.exist?(path)
+        m = File.read(path).match(/^category:\s*(.+?)\s*$/)
+        m && m[1].empty? ? nil : (m && m[1])
+      end
+
+      def prompt(input, output, message, default)
+        output.print "#{message} [#{default}]: "
+        answer = (input.gets || "").strip
+        answer.empty? ? default : answer
+      end
+
+      def validate_folder_name!(name, output: $stdout)
+        if name.nil? || name.empty? || name == "." || name == ".." || name.include?("/") || name.include?("\\")
+          output.puts "Error: invalid template folder name: #{name.inspect}"
+          raise FoobarTemplates::CLIError
+        end
+      end
+
+    end
+  end
+end

data/lib/foobar_templates/cli/setup_personal_templates_repo.rb

@@ -0,0 +1,135 @@
+module FoobarTemplates::CLI
+  module SetupPersonalTemplatesRepo
+    class << self
+
+      def go(input: $stdin, output: $stdout)
+        FoobarTemplates::validate_git_is_installed!
+        configurator = FoobarTemplates::Configurator.new
+
+        repo_domain = configurator.domain(:repo_domain)
+        if repo_domain.nil? || repo_domain.to_s.strip.empty?
+          output.puts "Error: `repo_domain` is not set in #{ENV['HOME']}/.foobar/config."
+          output.puts "Please set it (e.g. `repo_domain: github.com`) and re-run."
+          return
+        end
+
+        github_name = personal_templates_github_name(input: input, output: output)
+        return if github_name.nil? || github_name.empty?
+
+        local_dir = "#{ENV['HOME']}/.foobar/templates/templates-#{github_name}"
+        https_url = "https://#{repo_domain}/#{github_name}/templates-#{github_name}"
+        ssh_url   = "git@#{repo_domain}:#{github_name}/templates-#{github_name}.git"
+
+        if File.exist?(local_dir)
+          output.puts "The template directory already exists, #{local_dir}"
+          return
+        end
+
+        if remote_repo_exists?(https_url)
+          output.print "You already have a templates directory available at #{https_url}, clone it down? [Y/n] "
+          answer = (input.gets || "").strip.downcase
+          if answer == "" || answer == "y" || answer == "yes"
+            clone_personal_templates(local_dir, ssh_url, https_url, output: output)
+          else
+            output.puts "Aborted. No local directory was created."
+          end
+        else
+          init_personal_templates_dir(local_dir, github_name, ssh_url, output: output)
+        end
+      end
+
+      # Non-interactive resolver: returns the personal templates dir path based on
+      # `git config --global user.name`, or nil if that is not set. Does not prompt.
+      def personal_templates_dir
+        name = `git config --global user.name`.to_s.strip.downcase
+        return nil if name.empty?
+        "#{ENV['HOME']}/.foobar/templates/templates-#{name}"
+      end
+
+      def personal_templates_github_name(input: $stdin, output: $stdout)
+        name = `git config --global user.name`.to_s.strip
+        return name unless name.empty?
+
+        output.print "Enter your GitHub user name: "
+        answer = (input.gets || "").strip
+        if answer.empty?
+          output.puts "Error: GitHub user name is required."
+          return nil
+        end
+        answer
+      end
+
+      def remote_repo_exists?(url)
+        cmd = %(curl -o /dev/null -s -w "%{http_code}" -L #{url})
+        status = `#{cmd}`.to_s.strip
+        return false if status == "404"
+        # treat curl failure (empty status / non-numeric) as "exists" to avoid clobbering
+        true
+      end
+
+      def clone_personal_templates(local_dir, ssh_url, https_url, output: $stdout)
+        redirect = $test_env ? " 2> /dev/null" : ""
+        ssh_cmd = "git clone #{ssh_url} #{local_dir}#{redirect}"
+        `#{ssh_cmd}`
+        if $?.success?
+          output.puts "Cloned #{ssh_url} into #{local_dir}"
+          return
+        end
+
+        https_cmd = "git clone #{https_url} #{local_dir}#{redirect}"
+        `#{https_cmd}`
+        if $?.success?
+          output.puts "Cloned #{https_url} into #{local_dir}"
+        else
+          output.puts "Error: failed to clone from #{ssh_url} or #{https_url}."
+        end
+      end
+
+      def init_personal_templates_dir(local_dir, github_name, ssh_url, output: $stdout)
+        FileUtils.mkdir_p(local_dir)
+
+        File.write("#{local_dir}/foobar.yml", "monorepo: true\n")
+        File.write("#{local_dir}/README.md", personal_templates_readme(github_name))
+
+        redirect = $test_env ? " > /dev/null 2>&1" : ""
+        `cd #{local_dir} && git init#{redirect}`
+
+        output.puts "Created personal templates mono-repo at #{local_dir}"
+        output.puts "Next step: push it to your remote with:"
+        output.puts "  cd #{local_dir} && git remote add origin #{ssh_url}"
+      end
+
+      def personal_templates_readme(github_name)
+        <<~MARKDOWN
+          # templates-#{github_name}
+
+          This is a personal mono-repo of [foobar_templates](https://github.com/thenotary/foobar_templates)
+          templates. It was scaffolded by `foobar_templates --setup-personal-templates`.
+
+          ## Structure
+
+          Each immediate child directory is a template. A child becomes a template when
+          it contains its own `foobar.yml`. 
+
+          ```
+          templates-#{github_name}/
+            foobar.yml              # monorepo: true
+            README.md
+            my-widget-template/
+              foobar.yml            # category: frontend
+              foo-bar.rb
+            masm-project/
+              foobar.yml            # category: low_level
+              main.asm
+          ```
+
+          Run `foobar_templates --list` to see all templates discovered here, and
+          `foobar_templates --template <name> my-project` to scaffold a new project from one.
+
+          See https://github.com/thenotary/foobar_templates for full documentation.
+        MARKDOWN
+      end
+
+    end
+  end
+end