planter-cli 0.0.3 → 3.0.1

data/lib/planter/hash.rb

@@ -1,103 +1,100 @@
 # 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
+
+    ##  Destructive version of #stringify_keys
+    ##
+    ##  @return [Hash] Hash with stringified keys
+    ##
+    def stringify_keys!
+      replace stringify_keys
     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
+    ##
+    ## Destructive version of #symbolize_keys
+    ##
+    ## @return [Hash] Hash with symbolized keys
+    ##
+    def symbolize_keys!
+      replace symbolize_keys
     end
 
-    chilled.freeze
-  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
 
-  ##
-  ## 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
@@ -68,6 +68,8 @@ module Planter
     ## @example Pass a GitHub-style repo path and get full url
     ##   expand_repo("ttscoff/planter-cli") #=> https://github.com/ttscoff/planter-cli.git
     ##
+    ## @param      repo  [String] The repo
+    ##
     ## @return     { description_of_the_return_value }
     ##
     def expand_repo(repo)
@@ -177,15 +179,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

data/lib/planter/string.rb

@@ -23,7 +23,7 @@ module Planter
     ## @return     Class name representation of the object.
     ##
     def to_class_name
-      strip.no_ext.split(/[-_ ]/).map(&:capitalize).join('').gsub(/[^a-z0-9]/i, '')
+      strip.no_ext.title_case.gsub(/[^a-z0-9]/i, '').sub(/^\S/, &:upcase)
     end
 
     ##
@@ -66,7 +66,7 @@ module Planter
     ## @return     [String] Snake-cased version of string
     ##
     def snake_case
-      strip.gsub(/\S[A-Z]/) { |pair| pair.split('').join('_') }
+      strip.gsub(/\S(?=[A-Z])/, '\0_')
            .gsub(/[ -]+/, '_')
            .gsub(/[^a-z0-9_]+/i, '')
            .gsub(/_+/, '_')
@@ -82,7 +82,7 @@ module Planter
     ## @return     [String] Snake-cased version of string
     ##
     def camel_case
-      strip.gsub(/[ _]+(\S)/) { Regexp.last_match(1).upcase }
+      strip.gsub(/(?<=[^a-z0-9])(\S)/) { Regexp.last_match(1).upcase }
            .gsub(/[^a-z0-9]+/i, '')
            .sub(/^(\w)/) { Regexp.last_match(1).downcase }
     end
@@ -96,20 +96,11 @@ module Planter
     ## @return     [String] title cased string
     ##
     def title_case
-      gsub(/\b(\w)/) { Regexp.last_match(1).upcase }
+      split(/\b(\w+)/).map(&:capitalize).join('')
     end
 
-    ##
-    ## Apply key/value substitutions to a string. Variables are represented as
-    ## %%key%%, and the hash passed to the function is { key: value }
-    ##
-    ## @param      last_only  [Boolean] Only replace the last instance of %%key%%
-    ##
-    ## @return     [String] string with variables substituted
-    ##
-    def apply_variables(last_only: false)
-      content = dup.clean_encode
-      mod_rx = '(?<mod>
+    # @return [String] Regular expression for matching variable modifiers
+    MOD_RX = '(?<mod>
                   (?::
                     (
                       l(?:ow(?:er)?)?)?|
@@ -121,11 +112,75 @@ module Planter
                     )?
                   )*
                 )'
+    # @return [String] regular expression string for default values
+    DEFAULT_RX = '(?:%(?<default>[^%]+))?'
+
+    #
+    # Apply default values to a string
+    #
+    # Default values are applied to variables that are not present in the variables hash,
+    # or whose value matches the default value
+    #
+    # @param variables [Hash] Hash of variable values
+    #
+    # @return [String] string with default values applied
+    #
+    def apply_defaults(variables)
+      # Perform an in-place substitution on the content string for default values
+      gsub(/%%(?<varname>[^%:]+)(?<mods>(?::[^%]+)*)%(?<default>[^%]+)%%/) do
+        # Capture the last match object
+        m = Regexp.last_match
+
+        # Check if the variable is not present in the variables hash
+        if !variables.key?(m['varname'].to_var)
+          # If the variable is not present, use the default value from the match
+          m['default'].apply_var_names
+        else
+          # Retrieve the default value for the variable from the configuration
+          vars = Planter.config[:variables].filter { |v| v[:key] == m['varname'] }
+          default = vars.first[:default] if vars.count.positive?
+          if default.nil?
+            m[0]
+          elsif variables[m['varname'].to_var] == default
+            # If the variable's value matches the default value, use the default value from the match
+            m['default'].apply_var_names
+          else
+            m[0]
+          end
+        end
+      end
+    end
+
+    #
+    # Destructive version of #apply_defaults
+    #
+    # @param variables [Hash] hash of variables to apply
+    #
+    # @return [String] string with defaults applied
+    #
+    def apply_defaults!(variables)
+      replace apply_defaults(variables)
+    end
 
-      Planter.variables.each do |k, v|
+    ##
+    ## Apply key/value substitutions to a string. Variables are represented as
+    ## %%key%%, and the hash passed to the function is { key: value }
+    ##
+    ## @param      last_only  [Boolean] Only replace the last instance of %%key%%
+    ##
+    ## @return     [String] string with variables substituted
+    ##
+    def apply_variables(variables: nil, last_only: false)
+      variables = variables.nil? ? Planter.variables : variables
+
+      content = dup.clean_encode
+
+      content = content.apply_defaults(variables)
+
+      variables.each do |k, v|
         if last_only
           pattern = "%%#{k.to_var}"
-          content = content.reverse.sub(/(?mix)%%(?:(?<mod>.*?):)*(?<key>#{pattern.reverse})/) do
+          content = content.reverse.sub(/(?mix)%%(?:(?<mod>.*?):)*(?<key>#{pattern.reverse})/i) do
             m = Regexp.last_match
             if m['mod']
               m['mod'].reverse.split(/:/).each do |mod|
@@ -136,14 +191,16 @@ module Planter
             v.reverse
           end.reverse
         else
-          rx = /(?mix)%%(?<key>#{k.to_var})#{mod_rx}%%/
+          rx = /(?mix)%%(?<key>#{k.to_var})#{MOD_RX}#{DEFAULT_RX}%%/
 
           content.gsub!(rx) do
             m = Regexp.last_match
 
-            mods = m['mod']&.split(/:/)
-            mods&.each do |mod|
-              v = v.apply_mod(mod.normalize_mod)
+            if m['mod']
+              mods = m['mod']&.split(/:/)
+              mods&.each do |mod|
+                v = v.apply_mod(mod.normalize_mod)
+              end
             end
             v
           end
@@ -153,16 +210,49 @@ module Planter
       content
     end
 
+    #
+    # Handle $varname and ${varname} variable substitutions
+    #
+    # @return [String] String with variables substituted
+    #
+    def apply_var_names
+      sub(/\$\{?(?<varname>\w+)(?<mods>(?::\w+)+)?\}?/) do
+        m = Regexp.last_match
+        if Planter.variables.key?(m['varname'].to_var)
+          Planter.variables[m['varname'].to_var].apply_mods(m['mods'])
+        else
+          m
+        end
+      end
+    end
+
+    #
+    # Apply modifiers to a string
+    #
+    # @param mods [String] Colon separated list of modifiers to apply
+    #
+    # @return [String] string with modifiers applied
+    #
+    def apply_mods(mods)
+      content = dup
+      mods.split(/:/).each do |mod|
+        content.apply_mod!(mod.normalize_mod)
+      end
+      content
+    end
+
     ##
     ## Apply regex replacements from @config[:replacements]
     ##
     ## @return     [String] string with regexes applied
     ##
-    def apply_regexes
+    def apply_regexes(regexes = nil)
       content = dup.clean_encode
-      return self unless Planter.config.key?(:replacements)
+      regexes = regexes.nil? && Planter.config.key?(:replacements) ? Planter.config[:replacements] : regexes
 
-      Planter.config[:replacements].stringify_keys.each do |pattern, replacement|
+      return self unless regexes
+
+      regexes.stringify_keys.each do |pattern, replacement|
         pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
         replacement = replacement.gsub(/\$(\d)/, '\\\1').apply_variables
         content.gsub!(pattern, replacement)
@@ -177,8 +267,8 @@ module Planter
     ##
     ## @return     [String] string with variables substituted
     ##
-    def apply_variables!(last_only: false)
-      replace apply_variables(last_only: last_only)
+    def apply_variables!(variables: nil, last_only: false)
+      replace apply_variables(variables: variables, last_only: last_only)
     end
 
     ##
@@ -186,8 +276,8 @@ module Planter
     ##
     ## @return     [String] string with variables substituted
     ##
-    def apply_regexes!
-      replace apply_regexes
+    def apply_regexes!(regexes = nil)
+      replace apply_regexes(regexes)
     end
 
     ##
@@ -222,6 +312,8 @@ module Planter
     ##
     ## @param      mod   [Symbol] The modifier to apply
     ##
+    ## @return     [String] modified string
+    ##
     def apply_mod(mod)
       case mod
       when :slug
@@ -241,6 +333,17 @@ module Planter
       end
     end
 
+    #
+    # Destructive version of #apply_mod
+    #
+    # @param mod [String] modified string
+    #
+    # @return [<Type>] <description>
+    #
+    def apply_mod!(mod)
+      replace apply_mod(mod)
+    end
+
     ##
     ## Convert mod string to symbol
     ##
@@ -334,9 +437,11 @@ module Planter
     ##
     ##
     def coerce(type)
+      type = type.normalize_type
+
       case type
       when :date
-        Chronic.parse(self)
+        Chronic.parse(self).strftime('%Y-%m-%d %H:%M')
       when :integer || :number
         to_i
       when :float

data/lib/planter/tag.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Planter
+  module Tag
+    class << self
+      def set(target, tags)
+        tags = [tags] unless tags.is_a?(Array)
+
+        set_tags(target, tags)
+        $? == 0
+      end
+
+      # Add tags to a directory.
+      #
+      # @param dir [String] The directory to tag.
+      # @param tags [Array<String>] The tags to add.
+      def add(target, tags)
+        tags = [tags] unless tags.is_a?(Array)
+        existing_tags = get(target)
+        tags.concat(existing_tags).uniq!
+
+        set_tags(target, tags)
+        $? == 0
+      end
+
+      def get(target)
+        res = `xattr -p com.apple.metadata:_kMDItemUserTags "#{target}" 2>/dev/null`.clean_encode
+        return [] if res =~ /no such xattr/ || res.empty?
+
+        tags = Plist.parse_xml(res)
+
+        return false if tags.nil?
+
+        tags
+      end
+
+      def copy(source, target)
+        tags = `xattr -px com.apple.metadata:_kMDItemUserTags "#{source}" 2>/dev/null`
+        `xattr -wx com.apple.metadata:_kMDItemUserTags "#{tags}" "#{target}"`
+        $? == 0
+      end
+
+      private
+
+      def set_tags(target, tags)
+        tags.map! { |tag| "<string>#{tag}</string>" }
+        `xattr -w com.apple.metadata:_kMDItemUserTags '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+          <array>#{tags.join}</array>
+        </plist>' "#{target}"`
+      end
+    end
+  end
+end

data/lib/planter/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Planter
   # Current Planter version.
-  VERSION = '0.0.3'
+  VERSION = '3.0.1'
 end