planter-cli 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5445d6dfa3c8e0663006ce933f45f6e0717ccb4be51c67da0901c9606a5c70c
-  data.tar.gz: 0ee188813bbc0bb274837b130231dd937f403484d1a26adccee36b8126d2ee3f
+  metadata.gz: 5318772de94f6948e72fcf61709d9b0cf42c3518a775e47eaa816e8d432cf0f0
+  data.tar.gz: fcc04239c8d4c74af78f7da138d862f3a01ee053740cda5ad28e8e1019c11a29
 SHA512:
-  metadata.gz: 78a345ff2396c29c7beeadda989780003b5cc63174e4b9bcfcd0344350d8160fbb403231208ba1c3ca0d4bb66083711e675f5aad7dff5d14b226d59f31be6554
-  data.tar.gz: 1dc8ab448b3674319f6a469439d7b8dd6657a9c85061358fee7c7280a1fe9bb5910e4bf5d69e3223511bfccbd77c9e09c666b1441619ec0489e25d9c934fc048
+  metadata.gz: 55fd5cdd6bbede37bd171df3c6686fc4ca14c869895cf122f7a38997b46121516e32342ab7f8625b26762fba668cd73611c0edeac101fdf3d2d6ec325460dbfa
+  data.tar.gz: 865480b6ed5efda83cba2b0314bf1afd685eed88c2c930e6b705e4fb104da3fadc0afd85211ea2a4930370d0c786df342a6dbf7c4f0ab371b9122f6df895150b

data/.gitignore

@@ -41,4 +41,5 @@ Gemfile.lock
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
-test
+/test
+.history

data/.rubocop.yml

@@ -23,10 +23,6 @@ Style/MutableConstant:
 Style/SpecialGlobalVars:
   Enabled: false
 
-Security/YAMLLoad:
-  Exclude:
-    - 'lib/**/*.rb'
-
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: single_quotes
@@ -67,8 +63,7 @@ Metrics/ModuleLength:
   Max: 174
 
 Security/YAMLLoad:
-  Exclude:
-    - '**/*.rb'
+  Enabled: false
 
 Style/ModuleFunction:
   Exclude:
@@ -76,3 +71,6 @@ Style/ModuleFunction:
 
 Style/RaiseArgs:
   EnforcedStyle: compact
+
+Style/SlicingWithRange:
+  Enabled: false

data/Rakefile

@@ -107,10 +107,10 @@ task :dockertest, :version, :login, :attempt do |_, args|
   dir_args = dirs.map { |s, d| " -v '#{s}:#{d}'" }.join(' ')
   exec "docker run #{dir_args} -it #{img} /bin/bash -l" if args[:login]
 
-  spinner = TTY::Spinner.new("[:spinner] Running tests (#{args[:version]})...", hide_cursor: true)
+  spinner = TTY::Spinner.new("[:spinner] Running tests (#{version})...", hide_cursor: true)
 
   spinner.auto_spin
-  res = `docker run --rm #{dir_args} -it #{img}`
+  `docker run --rm #{dir_args} -it #{img}`
   # raise DockerError.new('Error running docker image') unless $?.success?
 
   # commit = puts `bash -c "docker commit $(docker ps -a|grep #{img}|awk '{print $1}'|head -n 1) #{img}"`.strip

data/bin/plant

@@ -22,6 +22,7 @@ options = {
 #   min: 1
 #   max: 5
 Planter.variables = {}
+Planter.base_dir = ENV['PLANTER_DIR'] || File.expand_path('~/.config/planter')
 Planter::Color.coloring = $stdout.isatty
 
 opts = OptionParser.new
@@ -53,6 +54,10 @@ opts.on('-o', '--overwrite', 'Overwrite existing files') do
   Planter.overwrite = true
 end
 
+opts.on_tail('--base-dir', 'Use an alternate base directory for config and templates') do |opt|
+  Planter.base_dir = opt
+end
+
 opts.on_tail('-d', '--debug', 'Display version number') do
   Planter.debug = true
 end
@@ -100,6 +105,7 @@ elsif ARGV.count.zero?
 end
 
 ARGV.each do |template|
+  Planter.spinner.update(title: 'Initializing configuration')
   Planter.config = template
   app = Planter::Plant.new
   app.plant

data/lib/planter/array.rb

@@ -24,5 +24,39 @@ module Planter
       end.join('{dw}/')
       out << '{dw}]{x}'
     end
+
+    ##
+    ## Stringify keys in an array of hashes or arrays
+    ##
+    ## @return [Array] Array with nested hash keys stringified
+    ##
+    def stringify_keys
+      each_with_object([]) do |v, arr|
+        arr << if v.is_a?(Hash)
+                 v.stringify_keys
+               elsif v.is_a?(Array)
+                 v.map { |x| x.is_a?(Hash) || x.is_a?(Array) ? x.stringify_keys : x }
+               else
+                 v
+               end
+      end
+    end
+
+    ##
+    ## Symbolize keys in an array of hashes or arrays
+    ##
+    ## @return [Array] Array with nested hash keys symbolized
+    ##
+    def symbolize_keys
+      each_with_object([]) do |v, arr|
+        arr << if v.is_a?(Hash)
+                 v.symbolize_keys
+               elsif v.is_a?(Array)
+                 v.map { |x| x.is_a?(Hash) || x.is_a?(Array) ? x.symbolize_keys : x }
+               else
+                 v
+               end
+      end
+    end
   end
 end

data/lib/planter/color.rb

@@ -81,7 +81,7 @@ module Planter
       [:default, '0;39']
     ].map(&:freeze).freeze
 
-    # Array of attribute keys only
+    # @return [Array<String>] all available color names
     ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
 
     # Returns true if Color supports the +feature+.

data/lib/planter/errors.rb

@@ -7,6 +7,7 @@ module Planter
     EXIT_CODES = {
       argument: 12,
       canceled: 1,
+      script: 10,
       config: 127,
       git: 129
     }.deep_freeze
@@ -55,5 +56,18 @@ module Planter
         super(msg)
       end
     end
+
+    #
+    # Script error
+    #
+    class ScriptError < StandardError
+      def initialize(msg = nil)
+        msg = msg ? "Script: #{msg}" : 'Script error'
+        Planter.spinner.error('(Error)')
+        Planter.notify(msg, :error, exit_code: EXIT_CODES[:script])
+
+        super(msg)
+      end
+    end
   end
 end

data/lib/planter/file.rb

@@ -2,10 +2,93 @@
 
 # Main module
 module Planter
-  def File.binary?(name)
-    IO.read(name) do |f|
-      f.each_byte { |x| x.nonzero? or return true }
+  # File helpers
+  class ::File
+    #
+    # Test if file is text
+    #
+    # @param name [String] file path
+    #
+    # @return [Boolean] File is text
+    #
+    def self.text?(name)
+      !binary?(name)
+    end
+
+    #
+    # Test if file is binary
+    #
+    # @param name [String] File path
+    #
+    # @return [Boolean] file is binary
+    #
+    def self.binary?(name)
+      return true if name.nil? || name.empty? || !File.exist?(name)
+
+      ascii = control = binary = 0
+
+      bytes = File.open(name, 'rb') { |io| io.read(1024) }
+      return true if bytes.nil? || bytes.empty?
+
+      bytes.each_byte do |bt|
+        case bt
+        when 0...32
+          control += 1
+        when 32...128
+          ascii += 1
+        else
+          binary += 1
+        end
+      end
+
+      first_test = binary.to_f / ascii > 0.05
+
+      first_test || second_test(name)
+    end
+
+    # Allowable text file types
+    TEXT_TYPES = %w[text ansi xml json yaml csv empty].freeze
+
+    #
+    # Secondary test with file command
+    #
+    # @param name [String] file path
+    #
+    # @return [Boolean] file is binary according to file command
+    #
+    def self.second_test(name)
+      if TTY::Which.exist?('file')
+        file_type, status = Open3.capture2e('file', name)
+        file_type = file_type.split(':')[1..-1].join(':').strip
+        if file_type =~ /Apple binary property list/ && TTY::Which.exist?('plutil')
+          `plutil -convert xml1 "#{name}"`
+          File.binary?(name)
+        else
+          status.success? && !text_type?(file_type)
+        end
+      else
+        false
+      end
+    end
+
+    #
+    # Tertiary test for binary file
+    #
+    # @param name [String] file path
+    #
+    # @return [Boolean] file is binary according to mdls
+    #
+    def self.third_test(name)
+      if TTY::Which.exist?('mdls')
+        file_type, status = Open3.capture2e('mdls', '-name', 'kMDItemContentTypeTree', name)
+        status.success? && !text_type?(file_type)
+      else
+        false
+      end
+    end
+
+    def self.text_type?(name)
+      TEXT_TYPES.any? { |type| name.downcase.include?(type) } || name.empty?
     end
-    false
   end
 end

data/lib/planter/filelist.rb

@@ -10,7 +10,7 @@ module Planter
     ##
     ## @param      path  [String] The base path for template
     ##
-    def initialize(path)
+    def initialize(path = Planter.base_dir)
       @basedir = File.realdirpath(path)
 
       search_path = File.join(@basedir, '**/*')
@@ -30,9 +30,9 @@ module Planter
     end
 
     ##
-    ## Public method for copying files based on their operator
+    ## Public method for copying @files to target based on their operator
     ##
-    ## @return     [Boolean] success
+    ## @return     [Boolean] success or failure
     ##
     def copy
       @files.each do |file|
@@ -89,36 +89,53 @@ module Planter
     end
 
     ##
-    ## Copy tagged merge sections from source to target
+    ## Copy tagged merge sections from source to target. If merge tags do not exist in the file,
+    ## append the entire file contents to the target.
     ##
     ## @param      entry  [FileEntry] The file entry
     ##
+    ## @return     [Boolean] success
+    ##
     def merge(entry)
       return copy_file(entry) if File.directory?(entry.file)
 
+      # Get the file type
       type = `file #{entry.file}`
       case type.sub(/^#{Regexp.escape(entry.file)}: /, '').split(/:/).first
       when /Apple binary property list/
+        # Convert to XML1 format
         `plutil -convert xml1 #{entry.file}`
         `plutil -convert xml1 #{entry.target}`
         content = IO.read(entry.file)
       when /data/
+        # Simply copy the file
         return copy_file(entry)
       else
+        # Copy the file if it is binary
         return copy_file(entry) if File.binary?(entry.file)
 
+        # Read the file content
         content = IO.read(entry.file)
       end
 
+      # Get the merge sections from the file, delimited by merge and /merge
       merges = content.scan(%r{(?<=\A|\n).{,4}merge *\n(.*?)\n.{,4}/merge}m)
                       &.map { |m| m[0].strip.apply_variables.apply_regexes }
+      # If no merge sections are found, use the entire file
       merges = [content] if !merges || merges.empty?
-      new_content = IO.read(entry.target)
-      merges.delete_if { |m| new_content =~ /#{Regexp.escape(m)}/ }
+
+      # Get the existing content of the target file
+      target_content = IO.read(entry.target)
+
+      # Remove any merges that already exist in the target file
+      merges.delete_if { |m| target_content =~ /#{Regexp.escape(m)}/ }
+
+      # If there are any merge sections left, merge them with the target file
       if merges.count.positive?
-        File.open(entry.target, 'w') { |f| f.puts "#{new_content.chomp}\n\n#{merges.join("\n\n")}" }
+        File.open(entry.target, 'w') { |f| f.puts "#{target_content.chomp}\n\n#{merges.join("\n\n")}" }
         Planter.notify("Merged #{entry.file} => #{entry.target} (#{merges.count} merges)", :debug)
       else
+        # If there are no merge sections left, copy the file instead
         copy_file(entry)
       end
     end
@@ -129,14 +146,25 @@ module Planter
     ## @param      file       [FileEntry] The file entry
     ## @param      overwrite  [Boolean] Force overwrite
     ##
+    ## @return     [Boolean] success
+    ##
     def copy_file(file, overwrite: false)
+      # Check if the target file already exists
+      # If it does and overwrite is true, or Planter.overwrite is true,
+      # or if the file doesn't exist, then copy the file
       if !File.exist?(file.target) || overwrite || Planter.overwrite
+        # Make sure the target directory exists
         FileUtils.mkdir_p(File.dirname(file.target))
+        # Copy the file if it isn't a directory
         FileUtils.cp(file.file, file.target) unless File.directory?(file.file)
+        # Log a message to the console
         Planter.notify("Copied #{file.file} => #{file.target}", :debug)
+        # Return true to indicate success
         true
       else
+        # Log a message to the console
         Planter.notify("Skipped #{file.file} => #{file.target}", :debug)
+        # Return false to indicate that the copy was skipped
         false
       end
     end

data/lib/planter/hash.rb

@@ -1,103 +1,84 @@
 # 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)
+module Planter
+  ## 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.is_a?(Array)
+                        v.stringify_keys
                       else
                         v
                       end
+      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
+    ##
+    ## 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.is_a?(Array)
+                          v.symbolize_keys
+                        else
+                          v
+                        end
       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
+    ##
+    ## 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
 
-    chilled.freeze
-  end
-
-  ##
-  ## Destructive version of #deep_freeze
-  ##
-  ## @return     [Hash] Hash with all values frozen
-  ##
-  def deep_freeze!
-    replace deep_thaw.deep_freeze
-  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
 
-  ##
-  ## 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
+      chilled.freeze
     end
 
-    chilled.dup
-  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
 
-  ##
-  ## Destructive version of #deep_thaw
-  ##
-  ## @return     [Hash] unfrozen hash
-  ##
-  def deep_thaw!
-    replace deep_thaw
+      chilled.dup
+    end
   end
 end

data/lib/planter/plant.rb

@@ -13,7 +13,7 @@ module Planter
       Planter.variables = variables if variables.is_a?(Hash)
       Planter.config = template if template
 
-      @basedir = File.join(Planter::BASE_DIR, 'templates', Planter.template)
+      @basedir = File.join(Planter.base_dir, 'templates', Planter.template)
       @target = Planter.target || Dir.pwd
 
       @git = Planter.config[:git_init] || false
@@ -177,15 +177,7 @@ module Planter
       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
+        next if File.binary?(file)
 
         content = IO.read(file)
         new_content = content.apply_variables.apply_regexes

data/lib/planter/prompt.rb

@@ -34,7 +34,7 @@ module Planter
       def ask
         return nil if @prompt.nil?
 
-        return @value.to_s.apply_variables.apply_regexes.coerce(@type) if @value
+        return @value.to_s.apply_variables.apply_regexes.coerce(@type) if @value && @type != :date
 
         res = case @type
               when :integer
@@ -133,7 +133,7 @@ module Planter
       ## @return     [String] the single-line response
       ##
       def read_line(prompt: nil)
-        prompt ||= read_lines @prompt
+        prompt ||= @prompt
         default = @default ? " {bw}[#{@default}]" : ''
         Planter.notify("{by}#{prompt}#{default}")
 
@@ -249,7 +249,7 @@ module Planter
       return default unless $stdout.isatty
 
       # If --defaults is set, return default
-      return default if Planter.accept_defaults
+      return default if Planter.accept_defaults || ENV['PLANTER_DEBUG']
 
       # clear the buffer
       if ARGV&.length
@@ -316,6 +316,9 @@ module Planter
                   default_response
                 end
 
+      # if PLANTER_DEBUG is set, answer default
+      return true if ENV['PLANTER_DEBUG']
+
       # if this isn't an interactive shell, answer default
       return default unless $stdout.isatty
 

data/lib/planter/script.rb

@@ -13,15 +13,24 @@ module Planter
     ## @param      script        [String] The script name
     ##
     def initialize(template_dir, output_dir, script)
-      found = find_script(template_dir, output_dir, script)
-      Planter.notify("Script #{script} not found", :error, exit_code: 10) unless found
+      found = find_script(template_dir, script)
+      raise ScriptError.new("Script #{script} not found") unless found
+
       @script = found
+      make_executable
+
+      raise ScriptError.new("Output directory #{output_dir} not found") unless File.directory?(output_dir)
 
-      Planter.notify("Directory #{output_dir} not found", :error, exit_code: 10) unless File.directory?(output_dir)
       @template_directory = template_dir
       @directory = output_dir
     end
 
+    ## Make a script executable if it's not already
+    def make_executable
+      File.chmod(0o755, @script) unless File.executable?(@script)
+      File.executable?(@script)
+    end
+
     ##
     ## Locate a script in either the base directory or template directory
     ##
@@ -31,13 +40,15 @@ module Planter
     ## @return     [String] Path to script
     ##
     def find_script(template_dir, script)
-      parts = Shellwords.split(script).first
-      return script if File.exist?(parts[0])
+      parts = Shellwords.split(script)
+      script_name = parts[0]
+      args = parts[1..-1].join(' ')
+      return script if File.exist?(script_name)
 
-      if File.exist?(File.join(template_dir, '_scripts', parts[0]))
-        return "#{File.join(template_dir, '_scripts', parts[0])} #{parts[1..-1]}"
-      elsif File.exist?(File.join(BASE_DIR, 'scripts', parts[0]))
-        return "#{File.join(BASE_DIR, 'scripts', parts[0])} #{parts[1..-1]}"
+      if File.exist?(File.join(template_dir, '_scripts', script_name))
+        return "#{File.join(template_dir, '_scripts', script_name)} #{args}".strip
+      elsif File.exist?(File.join(Planter.base_dir, 'scripts', script_name))
+        return "#{File.join(Planter.base_dir, 'scripts', script_name)} #{args}".strip
       end
 
       nil
@@ -49,9 +60,10 @@ module Planter
     ## @return     [Boolean] true if success?
     ##
     def run
-      `#{@script} "#{@template_directory}" "#{@directory}"`
-
-      Planter.notify("Error running #{File.basename(@script)}", :error, exit_code: 128) unless $?.success?
+      stdout, stderr, status = Open3.capture3(@script, @template_directory, @directory)
+      Planter.notify("STDOUT:\n#{stdout}", :debug) unless stdout.empty?
+      Planter.notify("STDERR:\n#{stderr}", :debug) unless stderr.empty?
+      raise ScriptError.new("Error running #{@script}") unless status.success?
 
       true
     end