planter-cli 0.0.3

data/lib/planter/file.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Main module
+module Planter
+  def File.binary?(name)
+    IO.read(name) do |f|
+      f.each_byte { |x| x.nonzero? or return true }
+    end
+    false
+  end
+end

data/lib/planter/fileentry.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Planter
+  # A single file entry in a FileList
+  class FileEntry < Hash
+    # Operation to execute on the file
+    attr_accessor :operation
+
+    # File path and target path
+    attr_reader :file, :target
+
+    ##
+    ## Initialize a FileEntry object
+    ##
+    ## @param      file       [String] The source file path
+    ## @param      target     [String] The target path
+    ## @param      operation  [Symbol] The operation to perform
+    ##
+    ## @return [FileEntry] a Hash of parameters
+    ##
+    def initialize(file, target, operation)
+      @file = file
+      @target = target
+      @operation = operation
+
+      super()
+    end
+
+    ##
+    ## Test if file matches any pattern in config
+    ##
+    ## @return     [Boolean] file matches pattern
+    ##
+    def matches_pattern?
+      Planter.patterns.filter { |pattern, _| @file =~ pattern }.count.positive?
+    end
+
+    ##
+    ## Determine operators based on configured filters,
+    ## asking for input if necessary
+    ##
+    ## @return     [Symbol] Operator
+    ##
+    def test_operator
+      operator = Planter.overwrite ? :overwrite : :copy
+      Planter.patterns.each do |pattern, op|
+        next unless @file =~ pattern
+
+        operator = op == :ask && !Planter.overwrite ? ask_operation : op
+        break
+      end
+      operator
+    end
+
+    ##
+    ## Prompt for file handling. If File exists, offer a merge/overwrite/ignore,
+    ## otherwise simply ask whether or not to copy.
+    ##
+    def ask_operation
+      if File.exist?(@target)
+        Prompt.file_what?(self)
+      else
+        res = Prompt.yn("Copy #{File.basename(@file)} to #{File.basename(@target)}",
+                        default_response: true)
+        res ? :copy : :ignore
+      end
+    end
+
+    ##
+    ## Returns a string representation of the object.
+    ##
+    ## @return     [String] String representation of the object.
+    ##
+    def inspect
+      "<FileEntry: @file: #{@file}, @target: #{@target}, @operation: #{@operation}>"
+    end
+
+    ##
+    ## Returns a string representation of the object contents.
+    ##
+    ## @return     [String] String representation of the object.
+    ##
+    def to_s
+      File.binary?(@file) ? 'Binary file' : IO.read(@file).to_s
+    end
+  end
+end

data/lib/planter/filelist.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Planter
+  # File listing class
+  class FileList
+    attr_reader :files
+
+    ##
+    ## Initialize a new FileList object
+    ##
+    ## @param      path  [String] The base path for template
+    ##
+    def initialize(path)
+      @basedir = File.realdirpath(path)
+
+      search_path = File.join(@basedir, '**/*')
+      files = Dir.glob(search_path, File::FNM_DOTMATCH).reject do |file|
+        file =~ %r{/(_scripts|\.git|_config\.yml$|\.{1,2}$)}
+      end
+
+      files.sort_by!(&:length)
+
+      @files = files.map do |file|
+        new_file = "#{Planter.target}#{file.sub(/^#{@basedir}/, '').apply_variables.apply_regexes}"
+        operation = Planter.overwrite ? :overwrite : :copy
+        FileEntry.new(file, new_file, operation)
+      end
+
+      prepare_copy
+    end
+
+    ##
+    ## Public method for copying files based on their operator
+    ##
+    ## @return     [Boolean] success
+    ##
+    def copy
+      @files.each do |file|
+        handle_operator(file)
+      end
+    rescue StandardError => e
+      Planter.notify("#{e}\n#{e.backtrace}", :debug)
+      Planter.notify('Error copying files/directories', :error, exit_code: 128)
+    end
+
+    private
+
+    ##
+    ## Perform operations
+    ##
+    ## @param      entry  [FileEntry] The file entry
+    ##
+    def handle_operator(entry)
+      case entry.operation
+      when :ignore
+        false
+      when :overwrite
+        copy_file(entry, overwrite: true)
+      when :merge
+        File.exist?(entry.target) ? merge(entry) : copy_file(entry)
+      else
+        copy_file(entry)
+      end
+    end
+
+    ##
+    ## Copy template files to new directory
+    ##
+    ## @return     [Boolean] success
+    ##
+    def prepare_copy
+      @files.each do |entry|
+        if entry.matches_pattern?
+          entry.operation = entry.test_operator
+          propogate_operation(entry)
+        end
+      end
+    end
+
+    ##
+    ## Apply a parent operation to children
+    ##
+    ## @param      entry  [FileEntry] The file entry
+    ##
+    def propogate_operation(entry)
+      @files.each do |file|
+        file.operation = entry.operation if file.file =~ /^#{entry.file}/
+      end
+    end
+
+    ##
+    ## Copy tagged merge sections from source to target
+    ##
+    ## @param      entry  [FileEntry] The file entry
+    ##
+    def merge(entry)
+      return copy_file(entry) if File.directory?(entry.file)
+
+      type = `file #{entry.file}`
+      case type.sub(/^#{Regexp.escape(entry.file)}: /, '').split(/:/).first
+      when /Apple binary property list/
+        `plutil -convert xml1 #{entry.file}`
+        `plutil -convert xml1 #{entry.target}`
+        content = IO.read(entry.file)
+      when /data/
+        return copy_file(entry)
+      else
+        return copy_file(entry) if File.binary?(entry.file)
+
+        content = IO.read(entry.file)
+      end
+
+      merges = content.scan(%r{(?<=\A|\n).{,4}merge *\n(.*?)\n.{,4}/merge}m)
+                      &.map { |m| m[0].strip.apply_variables.apply_regexes }
+      merges = [content] if !merges || merges.empty?
+      new_content = IO.read(entry.target)
+      merges.delete_if { |m| new_content =~ /#{Regexp.escape(m)}/ }
+      if merges.count.positive?
+        File.open(entry.target, 'w') { |f| f.puts "#{new_content.chomp}\n\n#{merges.join("\n\n")}" }
+        Planter.notify("Merged #{entry.file} => #{entry.target} (#{merges.count} merges)", :debug)
+      else
+        copy_file(entry)
+      end
+    end
+
+    ##
+    ## Perform file copy based on operator
+    ##
+    ## @param      file       [FileEntry] The file entry
+    ## @param      overwrite  [Boolean] Force overwrite
+    ##
+    def copy_file(file, overwrite: false)
+      if !File.exist?(file.target) || overwrite || Planter.overwrite
+        FileUtils.mkdir_p(File.dirname(file.target))
+        FileUtils.cp(file.file, file.target) unless File.directory?(file.file)
+        Planter.notify("Copied #{file.file} => #{file.target}", :debug)
+        true
+      else
+        Planter.notify("Skipped #{file.file} => #{file.target}", :debug)
+        false
+      end
+    end
+  end
+end

data/lib/planter/hash.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Hash helpers
+class ::Hash
+  ## Turn all keys into string
+  ##
+  ## @return     [Hash] copy of the hash where all its keys are strings
+  ##
+  def stringify_keys
+    each_with_object({}) do |(k, v), hsh|
+      hsh[k.to_s] = if v.is_a?(Hash)
+                      v.stringify_keys
+                    elsif v.is_a?(Array)
+                      v.map(&:symbolize_keys)
+                    else
+                      v
+                    end
+    end
+  end
+
+  ##
+  ## Turn all keys into symbols
+  ##
+  ## @return [Hash] hash with symbolized keys
+  ##
+  def symbolize_keys
+    each_with_object({}) do |(k, v), hsh|
+      hsh[k.to_sym] = if v.is_a?(Hash)
+                        v.symbolize_keys
+                      elsif v.is_a?(Array)
+                        v.map(&:symbolize_keys)
+                      else
+                        v
+                      end
+    end
+  end
+
+  ##
+  ## Deep merge a hash
+  ##
+  ## @param      second  [Hash] The hash to merge into self
+  ##
+  def deep_merge(second)
+    merger = proc do |_, v1, v2|
+      if v1.is_a?(Hash) && v2.is_a?(Hash)
+        v1.merge(v2, &merger)
+      elsif v1.is_a?(Array) && v2.is_a?(Array)
+        v1 | v2
+      elsif [:undefined, nil, :nil].include?(v2)
+        v1
+      else
+        v2
+      end
+    end
+    merge(second.to_h, &merger)
+  end
+
+  ##
+  ## Freeze all values in a hash
+  ##
+  ## @return     [Hash] Hash with all values frozen
+  ##
+  def deep_freeze
+    chilled = {}
+    each do |k, v|
+      chilled[k] = v.is_a?(Hash) ? v.deep_freeze : v.freeze
+    end
+
+    chilled.freeze
+  end
+
+  ##
+  ## Destructive version of #deep_freeze
+  ##
+  ## @return     [Hash] Hash with all values frozen
+  ##
+  def deep_freeze!
+    replace deep_thaw.deep_freeze
+  end
+
+  ##
+  ## Unfreeze a hash and all nested values
+  ##
+  ## @return     [Hash] unfrozen hash
+  ##
+  def deep_thaw
+    chilled = {}
+    each do |k, v|
+      chilled[k] = v.is_a?(Hash) ? v.deep_thaw : v.dup
+    end
+
+    chilled.dup
+  end
+
+  ##
+  ## Destructive version of #deep_thaw
+  ##
+  ## @return     [Hash] unfrozen hash
+  ##
+  def deep_thaw!
+    replace deep_thaw
+  end
+end

data/lib/planter/plant.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Planter
+  # Primary class
+  class Plant
+    ##
+    ## Initialize a new Plant object
+    ##
+    ## @param      template   [String] the template name
+    ## @param      variables  [Hash] Pre-populated variables
+    ##
+    def initialize(template = nil, variables = nil)
+      Planter.variables = variables if variables.is_a?(Hash)
+      Planter.config = template if template
+
+      @basedir = File.join(Planter::BASE_DIR, 'templates', Planter.template)
+      @target = Planter.target || Dir.pwd
+
+      @git = Planter.config[:git_init] || false
+      @debug = Planter.debug
+      @repo = Planter.config[:repo] || false
+
+      # Coerce any existing variables (like from the command line) to the types
+      # defined in configuration
+      coerced = {}
+      Planter.variables.each do |k, v|
+        cfg_var = Planter.config[:variables].select { |var| k = var[:key] }
+        next unless cfg_var.count.positive?
+
+        var = cfg_var.first
+        type = var[:type].normalize_type
+        coerced[k] = v.coerce(type)
+      end
+      coerced.each { |k, v| Planter.variables[k] = v }
+
+      # Ask user for any variables not already defined
+      Planter.config[:variables].each do |var|
+        key = var[:key].to_var
+        next if Planter.variables.keys.include?(key)
+
+        q = Planter::Prompt::Question.new(
+          key: key,
+          prompt: var[:prompt] || var[:key],
+          type: var[:type].normalize_type || :string,
+          default: var[:default],
+          value: var[:value],
+          min: var[:min],
+          max: var[:max]
+        )
+        answer = q.ask
+        if answer.nil?
+          Planter.notify("Missing value #{key}", :error, exit_code: 15) unless var[:default]
+
+          answer = var[:default]
+        end
+
+        Planter.variables[key] = answer
+      end
+
+      git_pull if @repo
+
+      @files = FileList.new(@basedir)
+    end
+
+    ##
+    ## Expand GitHub name to full path
+    ##
+    ## @example Pass a GitHub-style repo path and get full url
+    ##   expand_repo("ttscoff/planter-cli") #=> https://github.com/ttscoff/planter-cli.git
+    ##
+    ## @return     { description_of_the_return_value }
+    ##
+    def expand_repo(repo)
+      repo =~ %r{(?!=http)\w+/\w+} ? "https://github.com/#{repo}.git" : repo
+    end
+
+    ##
+    ## Directory for repo, subdirectory of template
+    ##
+    ## @return     [String] repo path
+    ##
+    def repo_dir
+      File.join(@basedir, File.basename(@repo).sub(/\.git$/, ''))
+    end
+
+    ##
+    ## Pull or clone a git repo
+    ##
+    ## @return     [String] new base directory
+    ##
+    def git_pull
+      Planter.spinner.update(title: 'Pulling git repo')
+
+      raise Errors::GitError.new('`git` executable not found') unless TTY::Which.exist?('git')
+
+      pwd = Dir.pwd
+      @repo = expand_repo(@repo)
+
+      if File.exist?(repo_dir)
+        Dir.chdir(repo_dir)
+        raise Errors::GitError.new("Directory #{repo_dir} exists but is not git repo") unless File.exist?('.git')
+
+        res = `git pull`
+        raise Errors::GitError.new("Error pulling #{@repo}:\n#{res}") unless $?.success?
+      else
+        Dir.chdir(@basedir)
+        res = `git clone "#{@repo}" "#{repo_dir}"`
+        raise Errors::GitError.new("Error cloning #{@repo}:\n#{res}") unless $?.success?
+      end
+      Dir.chdir(pwd)
+      @basedir = repo_dir
+    rescue StandardError => e
+      raise Errors::GitError.new("Error pulling #{@repo}:\n#{e.message}")
+    end
+
+    ##
+    ## Plant the template to current directory
+    ##
+    def plant
+      Dir.chdir(@target)
+
+      Planter.spinner.auto_spin
+      Planter.spinner.update(title: 'Copying files')
+      res = copy_files
+      if res.is_a?(String)
+        Planter.spinner.error("(#{res})")
+        Process.exit 1
+      end
+
+      Planter.spinner.update(title: 'Applying variables')
+
+      res = update_files
+      if res.is_a?(String)
+        Planter.spinner.error('(Error)')
+        Planter.notify(res, :error, exit_code: 1)
+      end
+
+      if @git
+        raise Errors::GitError.new('`git` executable not found') unless TTY::Which.exist?('git')
+
+        Planter.spinner.update(title: 'Initializing git repo')
+        res = add_git
+        if res.is_a?(String)
+          Planter.spinner.error('(Error)')
+          Planter.notify(res, :error, exit_code: 1)
+        end
+      end
+
+      if Planter.config[:script]
+        Planter.spinner.update(title: 'Running script')
+
+        scripts = Planter.config[:script]
+        scripts = [scripts] if scripts.is_a?(String)
+        scripts.each do |script|
+          s = Planter::Script.new(@basedir, Dir.pwd, script)
+          s.run
+        end
+      end
+      Planter.spinner.update(title: '😄')
+      Planter.spinner.success(' Planting complete!')
+    end
+
+    ##
+    ## Copy files from template directory, renaming if %%template vars%% exist in title
+    ##
+    ## @return     true if successful, otherwise error description
+    ##
+    def copy_files
+      @files.copy
+      true
+    end
+
+    ##
+    ## Update content of files in new directory using template variables
+    ##
+    def update_files
+      files = Dir.glob('**/*', File::FNM_DOTMATCH).reject { |f| File.directory?(f) || f =~ /^(\.git|config\.yml)/ }
+
+      files.each do |file|
+        type = `file #{file}`
+        case type.sub(/^#{Regexp.escape(file)}: /, '').split(/:/).first
+        when /Apple binary property list/
+          `plutil -convert xml1 #{file}`
+        when /data/
+          next
+        else
+          next if File.binary?(file)
+        end
+
+        content = IO.read(file)
+        new_content = content.apply_variables.apply_regexes
+
+        new_content.gsub!(%r{^.{.4}/?merge *.{,4}\n}, '') if new_content =~ /^.{.4}merge *\n/
+
+        unless content == new_content
+          Planter.notify("Applying variables to #{file}", :debug)
+          File.open(file, 'w') { |f| f.puts new_content }
+        end
+      end
+
+      true
+    rescue StandardError => e
+      Planter.notify("#{e}\n#{e.backtrace}", :debug)
+      'Error updating files/directories'
+    end
+
+    ##
+    ## Initialize a git repo and create initial commit/tag
+    ##
+    ## @return     true if successful, otherwise an error description
+    ##
+    def add_git
+      return if File.directory?('.git')
+
+      res = pass_fail('git init')
+      res = pass_fail('git add .') if res
+      res = pass_fail('git commit -a -m "initial commit"') if res
+      res = pass_fail('git tag -a 0.0.1 -m "v0.0.1"') if res
+
+      raise StandardError unless res
+
+      true
+    rescue StandardError => e
+      Planter.notify("#{e}\n#{e.backtrace}", :debug)
+      'Error initializing git'
+    end
+  end
+end