planter-cli 0.0.3 → 0.0.4

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/version.rb

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

data/lib/planter.rb

@@ -24,17 +24,19 @@ require_relative 'planter/prompt'
 require_relative 'planter/string'
 require_relative 'planter/filelist'
 require_relative 'planter/fileentry'
+require_relative 'planter/script'
 require_relative 'planter/plant'
 
 # Main Journal module
 module Planter
   # Base directory for templates
-  BASE_DIR = File.expand_path('~/.config/planter/')
-
   class << self
     include Color
     include Prompt
 
+    ## Base directory for templates
+    attr_writer :base_dir
+
     ## Debug mode
     attr_accessor :debug
 
@@ -72,7 +74,9 @@ module Planter
     def notify(string, notification_type = :info, exit_code: nil)
       case notification_type
       when :debug
-        warn "\n{dw}#{string}{x}".x if @debug
+        return false unless @debug
+
+        warn "\n{dw}#{string}{x}".x
       when :error
         warn "{br}#{string}{x}".x
       when :warn
@@ -82,6 +86,8 @@ module Planter
       end
 
       Process.exit exit_code unless exit_code.nil?
+
+      true
     end
 
     ##
@@ -97,6 +103,10 @@ module Planter
                                     error_mark: '{br}✖{x}'.x)
     end
 
+    def base_dir
+      @base_dir ||= ENV['PLANTER_BASE_DIR'] || File.join(Dir.home, '.config', 'planter')
+    end
+
     ##
     ## Build a configuration from template name
     ##
@@ -105,26 +115,30 @@ module Planter
     ## @return     [Hash] Configuration object
     ##
     def config=(template)
-      Planter.spinner.update(title: 'Initializing configuration')
       @template = template
       Planter.variables ||= {}
-      FileUtils.mkdir_p(BASE_DIR) unless File.directory?(BASE_DIR)
-      base_config = File.join(BASE_DIR, 'config.yml')
+      FileUtils.mkdir_p(Planter.base_dir) unless File.directory?(Planter.base_dir)
+      base_config = File.join(Planter.base_dir, 'planter.yml')
 
-      unless File.exist?(base_config)
+      if File.exist?(base_config)
+        @config = YAML.load(IO.read(base_config)).symbolize_keys
+      else
         default_base_config = {
           defaults: false,
           git_init: false,
           files: { '_planter.yml' => 'ignore' },
           color: true
         }
-        File.open(base_config, 'w') { |f| f.puts(YAML.dump(default_base_config.stringify_keys)) }
-        Planter.notify("New configuration written to #{config}, edit as needed.", :warn)
+        begin
+          File.open(base_config, 'w') { |f| f.puts(YAML.dump(default_base_config.stringify_keys)) }
+        rescue Errno::ENOENT
+          Planter.notify("Unable to create #{base_config}", :error)
+        end
+        @config = default_base_config.symbolize_keys
+        Planter.notify("New configuration written to #{base_config}, edit as needed.", :warn)
       end
 
-      @config = YAML.load(IO.read(base_config)).symbolize_keys
-
-      base_dir = File.join(BASE_DIR, 'templates', @template)
+      base_dir = File.join(Planter.base_dir, 'templates', @template)
       unless File.directory?(base_dir)
         notify("Template #{@template} does not exist", :error)
         res = Prompt.yn('Create template directory', default_response: false)
@@ -142,13 +156,36 @@ module Planter
       raise Errors::ConfigError.new "Parse error in configuration file:\n#{e.message}"
     end
 
+    ##
+    ## Execute a shell command and return a Boolean success response
+    ##
+    ## @param      cmd   [String] The shell command
+    ##
+    def pass_fail(cmd)
+      _, status = Open3.capture2("#{cmd} &> /dev/null")
+      status.exitstatus.zero?
+    end
+
+    ##
+    ## Patterns reader, file handling config
+    ##
+    ## @return     [Hash] hash of file patterns
+    ##
+    def patterns
+      @patterns ||= process_patterns
+    end
+
+    private
+
     ##
     ## Load a template-specific configuration
     ##
     ## @return     [Hash] updated config object
     ##
+    ## @api private
+    ##
     def load_template_config
-      base_dir = File.join(BASE_DIR, 'templates', @template)
+      base_dir = File.join(Planter.base_dir, 'templates', @template)
       config = File.join(base_dir, '_planter.yml')
 
       unless File.exist?(config)
@@ -165,8 +202,9 @@ module Planter
           git_init: false,
           files: { '*.tmp' => 'ignore' }
         }
+        FileUtils.mkdir_p(base_dir)
         File.open(config, 'w') { |f| f.puts(YAML.dump(default_config.stringify_keys)) }
-        puts "New configuration written to #{config}, please edit."
+        notify("New configuration written to #{config}, please edit.", :warn)
         Process.exit 0
       end
       @config = @config.deep_merge(YAML.load(IO.read(config)).symbolize_keys)
@@ -177,6 +215,8 @@ module Planter
     ##
     ## @param      key   [Symbol] The key in @config to convert
     ##
+    ## @api private
+    ##
     def config_array_to_hash(key)
       files = {}
       @config[key].each do |k, v|
@@ -185,20 +225,13 @@ module Planter
       @config[key] = files
     end
 
-    ##
-    ## Patterns reader, file handling config
-    ##
-    ## @return     [Hash] hash of file patterns
-    ##
-    def patterns
-      @patterns ||= process_patterns
-    end
-
     ##
     ## Process :files in config into regex pattern/operator pairs
     ##
     ## @return     [Hash] { regex => operator } hash
     ##
+    ## @api private
+    ##
     def process_patterns
       patterns = {}
       @config[:files].each do |file, oper|
@@ -208,15 +241,5 @@ module Planter
       end
       patterns
     end
-
-    ##
-    ## Execute a shell command and return a Boolean success response
-    ##
-    ## @param      cmd   [String] The shell command
-    ##
-    def pass_fail(cmd)
-      _, status = Open3.capture2("#{cmd} &> /dev/null")
-      status.exitstatus.zero?
-    end
   end
 end

data/spec/config.yml

@@ -0,0 +1,2 @@
+---
+git_init: false

data/spec/planter/array_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ::Array do
+  let(:array) { [1, 'value1', 'value2', { key1: 'value1', 'key2' => 'value2' }, %w[key1 key2]] }
+
+  describe '.stringify_keys' do
+    it 'converts string keys to strings' do
+      result = array.stringify_keys
+      expect(result).to eq([1, 'value1', 'value2', { 'key1' => 'value1', 'key2' => 'value2' }, %w[key1 key2]])
+    end
+  end
+
+  describe '.abbr_choices' do
+    it 'abbreviates the choices' do
+      arr = ['(o)ption 1', '(s)econd option', '(t)hird option']
+      result = arr.abbr_choices
+      expect(result).to match(%r{{xdw}\[{xbw}o{dw}/{xbw}s{dw}/{xbw}t{dw}\]{x}})
+    end
+
+    it 'handles a default' do
+      arr = ['(o)ption 1', '(s)econd option', '(t)hird option']
+      result = arr.abbr_choices(default: 'o')
+      expect(result).to match(%r{{xdw}\[{xbc}o{dw}/{xbw}s{dw}/{xbw}t{dw}\]{x}})
+    end
+  end
+end

data/spec/planter/file_entry_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Planter::FileEntry do
+  subject do
+    Planter::FileEntry.new(File.expand_path('spec/templates/test/test.rb'), File.expand_path('spec/test_out/test.rb'),
+                           :ignore)
+  end
+
+  describe '#initialize' do
+    it 'makes a new instance' do
+      expect(subject).to be_a described_class
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the name of the file' do
+      expect(subject.to_s).to be_a(String)
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns a string representation of the file' do
+      expect(subject.inspect).to be_a(String)
+    end
+  end
+
+  describe '#ask_operation' do
+    it 'returns :copy' do
+      expect(subject.ask_operation).to eq(:copy)
+    end
+
+    it 'returns :ignore for existing file' do
+      fileentry = Planter::FileEntry.new(File.expand_path('spec/templates/test/test.rb'), File.expand_path('spec/test_out/test2.rb'),
+                                         :ignore)
+      expect(fileentry.ask_operation).to eq(:ignore)
+    end
+  end
+end

data/spec/planter/file_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ::File do
+  describe '.binary?' do
+    it 'detects a non-binary text file' do
+      expect(File.binary?('spec/test_out/test2.rb')).to be(false)
+    end
+
+    it 'detects a binary image' do
+      expect(File.binary?('spec/test_out/image.png')).to be(true)
+    end
+
+    it 'recognizes json as text' do
+      expect(File.binary?('spec/test_out/doing.sublime-project')).to be(false)
+    end
+  end
+end

data/spec/planter/filelist_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Planter::FileList do
+  describe '#initialize' do
+    it 'initializes with an empty list' do
+      Planter.base_dir = File.expand_path('spec')
+      Planter.variables = { project: 'Untitled', script: 'Script', title: 'Title' }
+      Planter.config = 'test'
+      filelist = Planter::FileList.new
+      expect(filelist.files).not_to eq([])
+    end
+  end
+end

data/spec/planter/hash_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ::Hash do
+  let(:hash) { { 'key1' => 'value1', 'key2' => 'value2' } }
+
+  describe '.symbolize_keys' do
+    it 'converts string keys to symbols' do
+      string_hash = { 'key1' => 'value1', 'key2' => 'value2', 'key3' => ['value3'] }
+      result = string_hash.symbolize_keys
+      expect(result).to eq({ key1: 'value1', key2: 'value2', key3: ['value3'] })
+    end
+
+    it 'handles nested hashes' do
+      nested_hash = { 'outer' => { 'inner' => 'value' } }
+      result = nested_hash.symbolize_keys
+      expect(result).to eq({ outer: { inner: 'value' } })
+    end
+
+    it 'handles empty hashes' do
+      result = {}.symbolize_keys
+      expect(result).to eq({})
+    end
+  end
+
+  describe '.stringify_keys' do
+    it 'converts symbol keys to strings' do
+      symbol_hash = { key1: 'value1', key2: 'value2', key3: ['value3'] }
+      result = symbol_hash.stringify_keys
+      expect(result).to eq({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => ['value3'] })
+    end
+
+    it 'handles nested hashes' do
+      nested_hash = { outer: { inner: 'value' } }
+      result = nested_hash.stringify_keys
+      expect(result).to eq({ 'outer' => { 'inner' => 'value' } })
+    end
+
+    it 'handles empty hashes' do
+      result = {}.stringify_keys
+      expect(result).to eq({})
+    end
+  end
+
+  describe '.deep_merge' do
+    it 'merges two hashes deeply' do
+      hash1 = { a: 1, b: { c: 2 }, f: [1, 2] }
+      hash2 = { b: { d: 3 }, e: 4, f: [3, 4] }
+      result = hash1.deep_merge(hash2)
+      expect(result).to eq({ a: 1, b: { c: 2, d: 3 }, e: 4, f: [1, 2, 3, 4] })
+    end
+
+    it 'handles empty hashes' do
+      result = {}.deep_merge({})
+      expect(result).to eq({})
+    end
+
+    it 'does not modify the original hashes' do
+      hash1 = { a: 1, b: { c: 2 }, f: 'test' }
+      hash2 = { b: { d: 3 }, e: 4, f: nil }
+      hash1.deep_merge(hash2)
+      expect(hash1).to eq({ a: 1, b: { c: 2 }, f: 'test' })
+      expect(hash2).to eq({ b: { d: 3 }, e: 4, f: nil })
+    end
+  end
+
+  describe '.deep_freeze' do
+    it 'freezes all nested hashes' do
+      hash = { a: 1, b: { c: 2 } }.deep_freeze
+      expect(hash).to be_frozen
+      expect(hash[:b]).to be_frozen
+    end
+  end
+
+  describe '.deep_thaw' do
+    it 'thaws all nested hashes' do
+      hash = { a: 1, b: { c: 2 } }.deep_freeze.deep_thaw
+      expect(hash).not_to be_frozen
+      expect(hash[:b]).not_to be_frozen
+    end
+  end
+end

data/spec/planter/plant_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Planter::Plant do
   Planter.accept_defaults = true
+  Planter.base_dir = File.expand_path('spec')
   subject(:ruby_gem) { Planter::Plant.new('test', { project: 'Untitled', script: 'Script', title: 'Title' }) }
 
   describe '.new' do