foobar_templates 2.0.0

data/lib/foobar_templates/strings.rb

@@ -0,0 +1,23 @@
+module FoobarTemplates
+  HELP_MSG = <<-HEREDOC
+                    Foobar Templates version #{FoobarTemplates::VERSION}
+Use foobar_templates to start a new project folder based on a predefined template.
+
+Usage Examples:
+
+  # Download all my template files (configured in ~/.foobar/config)
+  $ foobar_templates --install-public-templates
+
+  # Create a personal mono-repo template for your projects
+  $ foobar_templates --setup-personal-templates
+
+  # Create a ruby gem project using the built in service template
+  $ foobar_templates --template ruby-cli-gem your_project_name
+
+  # Convert the current directory which represents a working project into a
+  # template by replacing project name variants with foo-bar placeholders
+  $ cd my_recently_built_project
+  $ foobar_templates --copy-to-templates
+  HEREDOC
+
+end

data/lib/foobar_templates/template_manager.rb

@@ -0,0 +1,119 @@
+require 'fileutils'
+require 'yaml'
+
+module FoobarTemplates
+
+  # This class handles the logic for finding templates
+  # in the user's dir, the gem's builtin templates
+  # (and on the web some day)
+  class TemplateManager
+
+    class << self
+
+      def internal_template_location() = File.expand_path("#{File.dirname(__FILE__)}/templates")
+      def custom_template_location() = File.expand_path("~/.foobar/templates")
+      def default_template_name() = "ruby-cli-gem"
+
+      def get_template_src(options)
+        template_name = options[:template] || default_template_name
+
+        if template_exists_within_repo?(template_name)
+          return resolve_template_path(internal_template_location, template_name)
+        end
+
+        custom_src = resolve_template_path(custom_template_location, template_name)
+        return custom_src if File.exist?(custom_src)
+
+        monorepo_match = resolve_monorepo_leaf_template(custom_template_location, template_name)
+        return monorepo_match if monorepo_match
+
+        raise FoobarTemplates::CLIError, "Error: template '#{template_name}' could not be found. Run the below command to list all available templates.\n\n  foobar_templates -l"
+      end
+
+      def template_exists_within_repo?(template_name)
+        file_in_source?(template_name) || file_in_source?("template-#{template_name}")
+      end
+
+      def resolve_template_path(location, name)
+        basic = "#{location}/#{name}"
+        prefixed = "#{location}/template-#{name}"
+
+        return basic if File.exist?(basic)
+        return prefixed if File.exist?(prefixed)
+
+        basic # fallback, even if it doesn't exist, will be caught by get_template_src
+      end
+
+      def resolve_monorepo_leaf_template(root, requested_name)
+        monorepo_roots = immediate_subdirectories(root).select { |dir| monorepo_directory?(dir) }
+        return nil if monorepo_roots.empty?
+
+        requested_leaf_name = requested_name.sub(/^template-/, "")
+        leaf_paths = monorepo_roots.flat_map { |dir| collect_leaf_templates(dir) }
+        matches = leaf_paths.select do |leaf_path|
+          File.basename(leaf_path).sub(/^template-/, "") == requested_leaf_name
+        end
+
+        if matches.length > 1
+          readable_paths = matches.map { |path| path.sub(/^#{Regexp.escape(root)}\//, "") }.sort.join(", ")
+          raise FoobarTemplates::CLIError, "Ambiguous template name '#{requested_name}'. Matching leaf templates: #{readable_paths}. Rename one of the conflicting templates."
+        end
+
+        if matches.empty?
+          readable_leaves = leaf_paths.map { |path| File.basename(path).sub(/^template-/, "") }.uniq.sort
+          raise FoobarTemplates::CLIError, "Template '#{requested_name}' not found in monorepo leaf templates. Available leaf templates: #{readable_leaves.join(', ')}. Run 'foobar_templates -l' to list all available templates."
+        end
+
+        matches.first
+      end
+
+      def collect_leaf_templates(dir)
+        config = load_template_config(dir)
+        return [] if config.nil?
+
+        if config[:monorepo] == true
+          immediate_subdirectories(dir).flat_map { |child| collect_leaf_templates(child) }
+        else
+          [dir]
+        end
+      end
+
+      def monorepo_directory?(dir)
+        config = load_template_config(dir)
+        !config.nil? && config[:monorepo] == true
+      end
+
+      def load_template_config(dir)
+        path = File.join(dir, "foobar.yml")
+        return nil unless File.exist?(path)
+
+        raw = YAML.load_file(path, symbolize_names: true)
+        raw.is_a?(Hash) ? raw : {}
+      rescue StandardError
+        {}
+      end
+
+      def immediate_subdirectories(dir)
+        return [] unless File.exist?(dir)
+
+        Dir.children(dir).filter_map do |entry|
+          full_path = File.join(dir, entry)
+          File.directory?(full_path) ? full_path : nil
+        end
+      end
+
+      def find_in_source_paths(target)
+        path = "#{__dir__}/templates/#{target}"
+        File.exist?(path) ? path : target
+      end
+
+      # Get's path to 'target' from within the gem's "templates" folder
+      # within the gem's source
+      def file_in_source?(target)
+        src_in_source_path = "#{File.dirname(__FILE__)}/templates/#{target}"
+        File.exist?(src_in_source_path)
+      end
+
+    end
+  end
+end

data/lib/foobar_templates/templates/template-test/foo-bar.rb

@@ -0,0 +1,16 @@
+This file shows all the variables in one place!
+See "lib/foobar_templates/templates/test_template/>>> foo-bar.rb"
+
+>>> foo-bar:               foo-bar
+>>> foo_bar:               foo_bar
+>>> FooBar:                FooBar
+>>> fooBar:                fooBar
+>>> FOO_BAR:               FOO_BAR
+>>> foo/bar:               foo/bar
+>>> foo_bar/foo_bar:       foo_bar/foo_bar
+>>> Foo::Bar:              Foo::Bar
+>>> FOO_AUTHOR:            FOO_AUTHOR
+>>> FOO_EMAIL:             FOO_EMAIL
+>>> FOO_GIT_REPO_DOMAIN:   FOO_GIT_REPO_DOMAIN
+>>> FOO_GIT_REPO_URL:      FOO_GIT_REPO_URL
+>>> FOO_GIT_REPO_PATH:     FOO_GIT_REPO_PATH

data/lib/foobar_templates/templates/template-test/foobar.yml

@@ -0,0 +1,2 @@
+purpose: tool
+language: go

data/lib/foobar_templates/templates/test_template/foo-bar.rb

@@ -0,0 +1,21 @@
+This file shows all the variables in one place!
+See "lib/foobar_templates/templates/test_template/>>> foo-bar.rb"
+
+>>> foo-bar:                  foo-bar
+>>> Foo Bar:                  Foo Bar
+>>> foo_bar:                  foo_bar
+>>> FooBar:                   FooBar
+>>> fooBar:                   fooBar
+>>> FOO_BAR:                  FOO_BAR
+>>> foo/bar:                  foo/bar
+>>> foo_bar/foo_bar:          foo_bar/foo_bar
+>>> Foo::Bar:                 Foo::Bar
+>>> FOO_AUTHOR:               FOO_AUTHOR
+>>> FOO_EMAIL:                FOO_EMAIL
+>>> FOO_GIT_REPO_DOMAIN:      FOO_GIT_REPO_DOMAIN
+>>> FOO_GIT_REPO_URL:         FOO_GIT_REPO_URL
+>>> FOO_GIT_REPO_PATH:        FOO_GIT_REPO_PATH
+>>> FOO_IMAGE_PATH:           FOO_IMAGE_PATH
+>>> FOO_REGISTRY_DOMAIN:      FOO_REGISTRY_DOMAIN
+>>> FOO_REGISTRY_REPO_PATH:   FOO_REGISTRY_REPO_PATH
+>>> FOO_K8S_DOMAIN:           FOO_K8S_DOMAIN

data/lib/foobar_templates/templates/test_template/foobar.yml

@@ -0,0 +1,2 @@
+purpose: tool
+language: go

data/lib/foobar_templates/version.rb

@@ -0,0 +1,3 @@
+module FoobarTemplates
+  VERSION = "2.0.0"
+end

data/lib/foobar_templates.rb

@@ -0,0 +1,151 @@
+require "foobar_templates/version"
+require "foobar_templates/strings"
+require 'foobar_templates/configurator'
+require 'foobar_templates/template_manager'
+
+require 'foobar_templates/core/core'
+require 'foobar_templates/cli/cli'
+
+require 'uri'
+
+SOURCE_ROOT = File.expand_path("#{File.dirname(__FILE__)}/..")
+
+module FoobarTemplates
+  class CLIError < StandardError; end
+
+  class << self
+
+    def version
+      FoobarTemplates::VERSION
+    end
+
+    def cheat_sheet
+      CLI::CheatSheet.go
+    end
+
+    # lists available templates
+    def list
+      configurator = Configurator.new
+      available_templates = configurator.collect_user_defined_templates
+
+      available_templates = group_hashes_by_key(available_templates)
+      output = convert_grouped_hashes_to_output(available_templates)
+
+      if output.empty?
+        empty_output_msg = "You have no templates.  You can install the public example templates with\n"
+        empty_output_msg += "the below command:\n\n"
+        empty_output_msg += "foobar_templates --install-public-templates"
+        return empty_output_msg
+      end
+
+      mark_default_template(output, configurator.default_template)
+    end
+
+    def install_public_templates
+      validate_git_is_installed!
+      configurator = Configurator.new
+      config_file_data = configurator.config_file_data
+      puts "Downloading templates from the following locations: \n  #{config_file_data['public_templates'].split(" ").join("\n  ")}"
+      config_file_data['public_templates'].split.each do |url|
+        uri = URI.parse(url)
+        template_folder_name = File.basename(uri.path).sub(/\.git$/, "")
+        if !File.exist?("#{ENV['HOME']}/.foobar/templates/#{template_folder_name}")
+          cmd = "cd #{ENV['HOME']}/.foobar/templates && git clone #{url}"
+          cmd += " 2> /dev/null" if $test_env
+          `#{cmd}`
+        else
+          puts "Warning: Skipping, template already exists #{ENV['HOME']}/.foobar/templates/#{template_folder_name}"
+        end
+      end
+    end
+
+    def validate_git_is_installed!
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "git#{ext}")
+          return if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+
+      raise CLIError, "Error: `git` command not found. Please install Git and ensure it's in your PATH."
+    end
+
+    def setup_personal_templates(input: $stdin, output: $stdout)
+      CLI::SetupPersonalTemplatesRepo.go(input: input, output: output)
+    end
+
+    def dir_to_template(input: $stdin, output: $stdout)
+      CLI::DirToTemplate.go(input: input, output: output)
+    end
+
+    def generate_template(options, gem_name)
+      require 'foobar_templates/cli/template_generator'
+
+      template_generator = CLI::TemplateGenerator.new(options, gem_name).run
+    rescue FoobarTemplates::CLIError => e
+      msg = e.message
+      $stderr.puts msg if msg && !msg.empty? && msg != e.class.name
+    end
+
+    # input:  [ { "predefined" => "default" },
+    #           { "MISC" => "my_thing" },
+    #           { "prdefined" => "service" }
+    #         ]
+    #
+    # output: [ { "predefined" => ["default", "service"] },
+    #           { "MISC" => ["my_thing"] }
+    #         ]
+    #
+    def group_hashes_by_key(available_templates)
+      h = {}
+      available_templates.each do |hash|
+        k = hash.first.first
+        v = hash.first.last
+        h[k] = [] unless h.has_key?(k)
+        h[k] << v
+      end
+      h
+    end
+
+    # input:  [ { "predefined" => ["default", "service"] },
+    #           { "MISC" => ["my_thing"] }
+    #         ]
+    def convert_grouped_hashes_to_output(available_templates)
+      template_list_output = ""
+      available_templates.each do |category, template_names|
+
+        template_list_output << " #{category&.upcase || "UNSPECIFIED"}:\n"
+        template_names.each do |el|
+          template_list_output << "   #{el}\n"
+        end
+        template_list_output << "\n"
+      end
+      template_list_output
+    end
+
+    def mark_default_template(output_string, default_template)
+      output_string.lines.reverse.map do |l|
+        if l.strip == default_template
+          l[1]= "*"
+          "#{l.chomp}       (default)\n"
+        else
+          l
+        end
+      end.reverse.join
+    end
+
+    def which(executable)
+      if File.file?(executable) && File.executable?(executable)
+        executable
+      elsif ENV['PATH']
+        path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
+          abs_path = File.join(p, executable)
+          File.file?(abs_path) && File.executable?(abs_path)
+        end
+        path && File.expand_path(executable, path)
+      end
+    end
+
+  end
+end

data/spec/data/variable_manifest_test.rb

@@ -0,0 +1,21 @@
+This file shows all the variables in one place!
+See "lib/foobar_templates/templates/test_template/foo-bar.rb"
+
+foo-bar:                  good-dog
+Foo Bar:                  Good Dog
+foo_bar:                  good_dog
+FooBar:                   GoodDog
+fooBar:                   goodDog
+FOO_BAR:                  GOOD_DOG
+foo/bar:                  good/dog
+foo_bar/foo_bar:          good_dog/good_dog
+Foo::Bar:                 Good::Dog
+FOO_AUTHOR:               Test
+FOO_EMAIL:                you@example.com
+FOO_GIT_REPO_DOMAIN:      github.com
+FOO_GIT_REPO_URL:         https://github.com/Test/good-dog
+FOO_GIT_REPO_PATH:        github.com/test/good-dog
+FOO_IMAGE_PATH:           test/good-dog
+FOO_REGISTRY_DOMAIN:      my-registry.example.com
+FOO_REGISTRY_REPO_PATH:   my-registry.example.com/test/good-dog
+FOO_K8S_DOMAIN:           my-k8s.example.com

data/spec/foobar_templates/cli/dir_to_template_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+module FoobarTemplates::CLI
+  describe DirToTemplate do
+    before :each do
+      @mocked_home    = "/tmp/foobar_templates_mock_home"
+      @template_root  = "#{@mocked_home}/.foobar/templates"
+      @dst_dir        = "/tmp/foobar_templates_dst_dir"
+      @personal_repo  = "#{@template_root}/templates-test" # name from reset_test_env
+
+      reset_test_env
+      FileUtils.cd(@dst_dir)
+      @initial_dir = FileUtils.pwd
+    end
+
+    after :each do
+      FileUtils.cd(@initial_dir)
+    end
+
+    def init_project(name, files: {})
+      project_dir = "#{@dst_dir}/#{name}"
+      FileUtils.mkdir_p(project_dir)
+      FileUtils.cd(project_dir)
+      files.each do |rel, contents|
+        FileUtils.mkdir_p(File.dirname(rel)) unless File.dirname(rel) == "."
+        File.write(rel, contents)
+      end
+      `git init -q && git add -A && git commit -q -m init`
+      project_dir
+    end
+
+    it "errors when no personal templates repo exists" do
+      init_project("cool-app", files: { "main.rb" => "puts 'hi'\n" })
+
+      out = StringIO.new
+      expect { DirToTemplate.go(input: StringIO.new(""), output: out) }.to raise_error(FoobarTemplates::CLIError)
+      expect(out.string).to include "Unable to convert to template, no personal templates repo exists."
+      expect(out.string).to include "foobar_templates --setup-personal-templates"
+    end
+
+    it "copies the project into the personal templates repo and runs the rename transform" do
+      FileUtils.mkdir_p(@personal_repo)
+      project_dir = init_project("cool-app", files: {
+        "main.rb"          => "class CoolApp; end\nNAME = 'cool-app'\nMOD = 'cool_app'\nENV_VAR = 'COOL_APP_HOME'\n",
+        ".gitignore"       => "ignored.log\n",
+        "lib/cool_app.rb"  => "module CoolApp; end\n",
+      })
+      File.write("#{project_dir}/ignored.log", "should not be copied")
+
+      out = StringIO.new
+      DirToTemplate.go(input: StringIO.new(""), output: out)
+
+      dest = "#{@personal_repo}/cool-app"
+      expect(File).to exist("#{dest}/main.rb")
+      expect(File).to exist("#{dest}/lib/cool_app.rb")
+      expect(File).to exist("#{dest}/.gitignore")
+      expect(File).not_to exist("#{dest}/ignored.log")
+      expect(File).not_to exist("#{dest}/.git")
+
+      content = File.read("#{dest}/main.rb")
+      expect(content).to include "FooBar"
+      expect(content).to include "foo-bar"
+      expect(content).to include "foo_bar"
+      expect(content).to include "FOO_BAR"
+      expect(content).not_to include "cool-app"
+      expect(content).not_to include "CoolApp"
+
+      expect(File.read("#{dest}/foobar.yml")).to include "category: misc"
+
+      expect(out.string).to include "Template created at: #{dest}"
+      expect(out.string).to match(/clean|review|remove/i)
+    end
+
+    it "preserves an existing foobar.yml in the source project" do
+      FileUtils.mkdir_p(@personal_repo)
+      init_project("cool-app", files: {
+        "foobar.yml" => "category: backend\n",
+        "main.rb"       => "puts 'hi'\n",
+      })
+
+      DirToTemplate.go(input: StringIO.new(""), output: StringIO.new)
+
+      dest = "#{@personal_repo}/cool-app"
+      expect(File.read("#{dest}/foobar.yml")).to include "category: backend"
+    end
+
+    it "prompts for a custom template folder name and category" do
+      FileUtils.mkdir_p(@personal_repo)
+      init_project("cool-app", files: {
+        "main.rb"         => "class CoolApp; end\nNAME = 'cool-app'\n",
+        "lib/cool_app.rb" => "module CoolApp; end\n",
+      })
+
+      out = StringIO.new
+      DirToTemplate.go(input: StringIO.new("my-cool-template\nbackend\n"), output: out)
+
+      dest = "#{@personal_repo}/my-cool-template"
+      expect(File).to exist("#{dest}/main.rb")
+      expect(File.read("#{dest}/foobar.yml")).to include "category: backend"
+
+      content = File.read("#{dest}/main.rb")
+      expect(content).to include "FooBar"
+      expect(content).to include "foo-bar"
+      expect(content).not_to include "cool-app"
+      expect(content).not_to include "CoolApp"
+    end
+
+    it "defaults the category prompt to the existing foobar.yml category" do
+      FileUtils.mkdir_p(@personal_repo)
+      init_project("cool-app", files: {
+        "foobar.yml" => "category: backend\n",
+        "main.rb"       => "puts 'hi'\n",
+      })
+
+      out = StringIO.new
+      DirToTemplate.go(input: StringIO.new("\n\n"), output: out)
+
+      expect(out.string).to include "Category [backend]:"
+      expect(File.read("#{@personal_repo}/cool-app/foobar.yml")).to include "category: backend"
+    end
+
+    it "rejects invalid template folder names" do
+      FileUtils.mkdir_p(@personal_repo)
+      init_project("cool-app", files: { "main.rb" => "x" })
+
+      out = StringIO.new
+      expect {
+        DirToTemplate.go(input: StringIO.new("bad/name\n"), output: out)
+      }.to raise_error(FoobarTemplates::CLIError)
+      expect(out.string).to include "invalid template folder name"
+    end
+
+    it "aborts if a template with the same basename already exists" do
+      FileUtils.mkdir_p("#{@personal_repo}/cool-app")
+      init_project("cool-app", files: { "main.rb" => "x" })
+
+      out = StringIO.new
+      expect { DirToTemplate.go(input: StringIO.new(""), output: out) }.to raise_error(FoobarTemplates::CLIError)
+      expect(out.string).to include "already exists at #{@personal_repo}/cool-app"
+    end
+
+    it "errors when not run inside a git repository" do
+      FileUtils.mkdir_p(@personal_repo)
+      project_dir = "#{@dst_dir}/no-git-app"
+      FileUtils.mkdir_p(project_dir)
+      FileUtils.cd(project_dir)
+
+      out = StringIO.new
+      expect { DirToTemplate.go(input: StringIO.new(""), output: out) }.to raise_error(FoobarTemplates::CLIError)
+      expect(out.string).to include "must be run from within a git repository"
+    end
+  end
+end

data/spec/foobar_templates/core/dir_to_template_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'find'
+
+module FoobarTemplates::Core
+  describe DirToTemplate do
+    before :each do
+      @mocked_home = "/tmp/foobar_templates_mock_home"
+      @template_root = "#{@mocked_home}/.foobar/templates"
+      @dst_dir = "/tmp/foobar_templates_dst_dir"
+
+      reset_test_env
+      FileUtils.chdir(@dst_dir)
+      @initial_dir = FileUtils.pwd
+    end
+
+    after :each do
+      FileUtils.cd(@initial_dir)
+    end
+
+    it 'will process the expected files and ignore the ones that should be ignored' do
+      template_dir = create_user_defined_template(category: "wizardly_tools")
+
+      gitignored_file = "something.toignore"
+
+      # Setup test template
+      FileUtils.cd(template_dir)
+      FileUtils.touch("#{template_dir}/README.md")
+      FileUtils.touch("#{template_dir}/#{gitignored_file}")
+      File.write("#{template_dir}/.gitignore", gitignored_file)
+      `git init`
+
+      files_changed = DirToTemplate.🧙🪄! Find.find("."), dry_run: true
+
+      expect(files_changed[0]).to eq "Processed: ./README.md"
+      expect(File).to exist "#{template_dir}/.gitignore"
+      expect(files_changed.count).to eq 1
+    end
+
+    it 'conducts text replacements of package name variants' do
+      template_dir = create_user_defined_template(category: "wizardly_tools")
+      template_name = "cool-app"
+
+      FileUtils.cd(template_dir)
+      File.write("#{template_dir}/main.go", "package cool_app\nconst Name = \"cool-app\"\nconst ENV = \"COOL_APP_ENV\"\nclass CoolApp\n  def coolApp\n  end\nend\n")
+      File.write("#{template_dir}/.gitignore", "")
+      `git init`
+
+      DirToTemplate.🧙🪄! Find.find("."), template_name: template_name
+
+      content = File.read("#{template_dir}/main.go")
+      expect(content).to include 'foo_bar'
+      expect(content).to include 'foo-bar'
+      expect(content).to include 'FOO_BAR'
+      expect(content).to include 'FooBar'
+      expect(content).to include 'fooBar'
+      expect(content).not_to include 'cool-app'
+      expect(content).not_to include 'cool_app'
+      expect(content).not_to include 'COOL_APP'
+      expect(content).not_to include 'CoolApp'
+      expect(content).not_to include 'coolApp'
+    end
+
+    it 'reverse-substitutes FOO_* placeholder values from git config and foobar_templates config' do
+      template_dir = create_user_defined_template(category: "wizardly_tools")
+      template_name = "good-dog"
+
+      FileUtils.cd(template_dir)
+      manifest = <<~CONTENT
+        author: Test
+        email: you@example.com
+        repo_domain: github.com
+        repo_url: https://github.com/Test/good-dog
+        repo_path: github.com/test/good-dog
+        image_path: test/good-dog
+        registry_domain: my-registry.example.com
+        registry_repo_path: my-registry.example.com/test/good-dog
+        k8s_domain: my-k8s.example.com
+      CONTENT
+      File.write("#{template_dir}/manifest.txt", manifest)
+      File.write("#{template_dir}/.gitignore", "")
+      `git init`
+
+      DirToTemplate.🧙🪄! Find.find("."), template_name: template_name
+
+      content = File.read("#{template_dir}/manifest.txt")
+      expect(content).to include 'FOO_AUTHOR'
+      expect(content).to include 'FOO_EMAIL'
+      expect(content).to include 'FOO_GIT_REPO_DOMAIN'
+      expect(content).to include 'FOO_GIT_REPO_URL'
+      expect(content).to include 'FOO_GIT_REPO_PATH'
+      expect(content).to include 'FOO_IMAGE_PATH'
+      expect(content).to include 'FOO_REGISTRY_DOMAIN'
+      expect(content).to include 'FOO_REGISTRY_REPO_PATH'
+      expect(content).to include 'FOO_K8S_DOMAIN'
+
+      expect(content).not_to include 'you@example.com'
+      expect(content).not_to include 'github.com'
+      expect(content).not_to include 'my-registry.example.com'
+      expect(content).not_to include 'my-k8s.example.com'
+      expect(content).not_to include 'good-dog'
+      expect(content).not_to include 'good_dog'
+    end
+  end
+end