planter-cli 0.0.3 → 3.0.1

data/lib/planter.rb

@@ -6,6 +6,7 @@ require 'json'
 require 'yaml'
 require 'fileutils'
 require 'open3'
+require 'plist'
 
 require 'chronic'
 require 'tty-reader'
@@ -18,23 +19,26 @@ require_relative 'planter/hash'
 require_relative 'planter/array'
 require_relative 'planter/symbol'
 require_relative 'planter/file'
+require_relative 'planter/tag'
 require_relative 'planter/color'
 require_relative 'planter/errors'
 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 +76,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 +88,8 @@ module Planter
       end
 
       Process.exit exit_code unless exit_code.nil?
+
+      true
     end
 
     ##
@@ -97,6 +105,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 +117,31 @@ 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
+          color: true,
+          preserve_tags: 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 +159,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 +205,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 +218,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 +228,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 +244,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/planter-cli.gemspec

@@ -41,6 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard', '~> 0.9.5'
 
   spec.add_runtime_dependency 'chronic', '~> 0.10'
+  spec.add_runtime_dependency 'plist', '~> 3.7.1'
   spec.add_runtime_dependency 'tty-reader', '~> 0.9'
   spec.add_runtime_dependency 'tty-screen', '~> 0.8'
   spec.add_runtime_dependency 'tty-spinner', '~> 0.9'

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,110 @@
+# 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
+
+  describe '#stringify_keys!' do
+    let(:hash) { { key1: 'value1', key2: 'value2', key3: { key4: 'value4' } } }
+
+    it 'converts symbol keys to strings destructively' do
+      hash.stringify_keys!
+      expect(hash).to eq({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => { 'key4' => 'value4' } })
+    end
+
+    it 'does not modify the original hash if already string keys' do
+      string_hash = { 'key1' => 'value1', 'key2' => 'value2', 'key3' => { 'key4' => 'value4' } }
+      string_hash.stringify_keys!
+      expect(string_hash).to eq({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => { 'key4' => 'value4' } })
+    end
+
+    it 'handles nested hashes' do
+      nested_hash = { key1: { key2: { key3: 'value3' } } }
+      nested_hash.stringify_keys!
+      expect(nested_hash).to eq({ 'key1' => { 'key2' => { 'key3' => 'value3' } } })
+    end
+
+    it 'handles empty hashes' do
+      empty_hash = {}
+      empty_hash.stringify_keys!
+      expect(empty_hash).to eq({})
+    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

data/spec/planter/script_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+
+describe Planter::Script do
+  let(:template_dir) { File.expand_path('spec/templates/test') }
+  let(:output_dir) { File.expand_path('spec/test_out') }
+  let(:script_name) { 'test.sh' }
+  let(:script_name_fail) { 'test_fail.sh' }
+  let(:script_path) { File.join(template_dir, '_scripts', script_name) }
+  let(:base_script_path) { File.join(Planter.base_dir, 'scripts', script_name) }
+
+  before do
+    Planter.base_dir = File.expand_path('spec')
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:directory?).and_call_original
+    allow(File).to receive(:exist?).with(script_path).and_return(true)
+    allow(File).to receive(:exist?).with(base_script_path).and_return(false)
+    allow(File).to receive(:directory?).with(output_dir).and_return(true)
+  end
+
+  describe '#initialize' do
+    it 'initializes with valid script and directories' do
+      script = Planter::Script.new(template_dir, output_dir, script_name)
+      expect(script.script).to eq(script_path)
+    end
+
+    it 'raises an error if script is not found' do
+      allow(File).to receive(:exist?).with(script_path).and_return(false)
+      expect do
+        Planter::Script.new(template_dir, output_dir, script_name)
+      end.to raise_error(ScriptError)
+    end
+
+    it 'raises an error if output directory is not found' do
+      allow(File).to receive(:directory?).with(output_dir).and_return(false)
+      expect do
+        Planter::Script.new(template_dir, output_dir, script_name)
+      end.to raise_error(ScriptError)
+    end
+  end
+
+  describe '#find_script' do
+    it 'finds the script in the template directory' do
+      script = Planter::Script.new(template_dir, output_dir, script_name)
+      expect(script.find_script(template_dir, script_name)).to eq(script_path)
+    end
+
+    it 'finds the script in the base directory' do
+      allow(File).to receive(:exist?).with(script_path).and_return(false)
+      allow(File).to receive(:exist?).with(base_script_path).and_return(true)
+      script = Planter::Script.new(template_dir, output_dir, script_name)
+      expect(script.find_script(template_dir, script_name)).to eq(base_script_path)
+    end
+
+    it 'returns nil if script is not found' do
+      allow(File).to receive(:exist?).with(script_path).and_return(false)
+      allow(File).to receive(:exist?).with(base_script_path).and_return(false)
+      expect do
+        script = Planter::Script.new(template_dir, output_dir, script_name)
+        script.find_script(template_dir, script_name)
+      end.to raise_error(ScriptError)
+    end
+  end
+
+  describe '#run' do
+    it 'executes the script successfully' do
+      script = Planter::Script.new(template_dir, output_dir, script_name)
+      expect(script.run).to be true
+    end
+
+    it 'raises an error if script execution fails' do
+      script = Planter::Script.new(template_dir, output_dir, script_name_fail)
+      expect do
+        script.run
+      end.to raise_error(ScriptError)
+    end
+  end
+end