planter-cli 0.0.3

data/lib/planter/string.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+module Planter
+  ## String helpers
+  class ::String
+    ##
+    ## Convert string to snake-cased variable name
+    ##
+    ## @example    "Planter String" #=> planter_string
+    ## @example    "Planter-String" #=> planter_string
+    ##
+    ## @return     [Symbol] string as variable key
+    ##
+    def to_var
+      snake_case.to_sym
+    end
+
+    ##
+    ## Convert a slug into a class name
+    ##
+    ## @example    "planter-string".to_class_name #=> PlanterString
+    ##
+    ## @return     Class name representation of the object.
+    ##
+    def to_class_name
+      strip.no_ext.split(/[-_ ]/).map(&:capitalize).join('').gsub(/[^a-z0-9]/i, '')
+    end
+
+    ##
+    ## Convert a class name to a file slug
+    ##
+    ## @example    "PlanterString".to_class_name #=> planter-string
+    ##
+    ## @return     Filename representation of the object.
+    ##
+    def to_slug
+      strip.split(/(?=[A-Z ])/).map(&:downcase).join('-')
+           .gsub(/[^a-z0-9_-]/i, &:slugify)
+           .gsub(/-+/, '-')
+           .gsub(/(^-|-$)/, '')
+    end
+
+    ## Convert some characters to text
+    ##
+    ## @return [String] slugified character or empty string
+    ##
+    def slugify
+      char = to_s
+      slug_version = {
+        '.' => 'dot',
+        '/' => 'slash',
+        ':' => 'colon',
+        ',' => 'comma',
+        '!' => 'bang',
+        '#' => 'hash'
+      }
+      slug_version[char] ? "-#{slug_version[char]}-" : ''
+    end
+
+    ##
+    ## Convert a string to snake case, handling spaces or CamelCasing
+    ##
+    ## @example    "ClassName".snake_case #=> class-name
+    ## @example    "A title string".snake_case #=> a-title-string
+    ##
+    ## @return     [String] Snake-cased version of string
+    ##
+    def snake_case
+      strip.gsub(/\S[A-Z]/) { |pair| pair.split('').join('_') }
+           .gsub(/[ -]+/, '_')
+           .gsub(/[^a-z0-9_]+/i, '')
+           .gsub(/_+/, '_')
+           .gsub(/(^_|_$)/, '').downcase
+    end
+
+    ##
+    ## Convert a string to camel case, handling spaces or snake_casing
+    ##
+    ## @example    "class_name".camel_case #=> className
+    ## @example    "A title string".camel_case #=> aTitleString
+    ##
+    ## @return     [String] Snake-cased version of string
+    ##
+    def camel_case
+      strip.gsub(/[ _]+(\S)/) { Regexp.last_match(1).upcase }
+           .gsub(/[^a-z0-9]+/i, '')
+           .sub(/^(\w)/) { Regexp.last_match(1).downcase }
+    end
+
+    ##
+    ## Capitalize the first character after a word border. Prevents downcasing
+    ## intercaps.
+    ##
+    ## @example    "a title string".title_case #=> A Title String
+    ##
+    ## @return     [String] title cased string
+    ##
+    def title_case
+      gsub(/\b(\w)/) { Regexp.last_match(1).upcase }
+    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>
+                  (?::
+                    (
+                      l(?:ow(?:er)?)?)?|
+                      u(?:p(?:per)?)?|
+                      c(?:ap(?:ital(?:ize)?)?)?|
+                      t(?:itle)?|
+                      snake|camel|slug|
+                      f(?:ile(?:name)?
+                    )?
+                  )*
+                )'
+
+      Planter.variables.each do |k, v|
+        if last_only
+          pattern = "%%#{k.to_var}"
+          content = content.reverse.sub(/(?mix)%%(?:(?<mod>.*?):)*(?<key>#{pattern.reverse})/) do
+            m = Regexp.last_match
+            if m['mod']
+              m['mod'].reverse.split(/:/).each do |mod|
+                v = v.apply_mod(mod.normalize_mod)
+              end
+            end
+
+            v.reverse
+          end.reverse
+        else
+          rx = /(?mix)%%(?<key>#{k.to_var})#{mod_rx}%%/
+
+          content.gsub!(rx) do
+            m = Regexp.last_match
+
+            mods = m['mod']&.split(/:/)
+            mods&.each do |mod|
+              v = v.apply_mod(mod.normalize_mod)
+            end
+            v
+          end
+        end
+      end
+
+      content
+    end
+
+    ##
+    ## Apply regex replacements from @config[:replacements]
+    ##
+    ## @return     [String] string with regexes applied
+    ##
+    def apply_regexes
+      content = dup.clean_encode
+      return self unless Planter.config.key?(:replacements)
+
+      Planter.config[:replacements].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)
+      end
+      content
+    end
+
+    ##
+    ## Destructive version of #apply_variables
+    ##
+    ## @param      last_only  [Boolean] Only replace the last instance of %%key%%
+    ##
+    ## @return     [String] string with variables substituted
+    ##
+    def apply_variables!(last_only: false)
+      replace apply_variables(last_only: last_only)
+    end
+
+    ##
+    ## Destructive version of #apply_regexes
+    ##
+    ## @return     [String] string with variables substituted
+    ##
+    def apply_regexes!
+      replace apply_regexes
+    end
+
+    ##
+    ## Remove any file extension
+    ##
+    ## @example    "planter-string.rb".no_ext #=> planter-string
+    ##
+    ## @return     [String] string with no extension
+    ##
+    def no_ext
+      sub(/\.\w{2,4}$/, '')
+    end
+
+    ##
+    ## Add an extension to the string, replacing existing extension if needed
+    ##
+    ## @example    "planter-string".ext('rb') #=> planter-string.rb
+    ##
+    ## @example    "planter-string.rb".ext('erb') #=> planter-string.erb
+    ##
+    ## @param      extension  [String] The extension to add
+    ##
+    ## @return     [String] string with new extension
+    ##
+    def ext(extension)
+      extension = extension.sub(/^\./, '')
+      sub(/(\.\w+)?$/, ".#{extension}")
+    end
+
+    ##
+    ## Apply a modification to string
+    ##
+    ## @param      mod   [Symbol] The modifier to apply
+    ##
+    def apply_mod(mod)
+      case mod
+      when :slug
+        to_slug
+      when :title_case
+        title_case
+      when :lowercase
+        downcase
+      when :uppercase
+        upcase
+      when :snake_case
+        snake_case
+      when :camel_case
+        camel_case
+      else
+        self
+      end
+    end
+
+    ##
+    ## Convert mod string to symbol
+    ##
+    ## @example "snake" => :snake_case
+    ## @example "cap" => :title_case
+    ##
+    ## @return     [Symbol] symbolized modifier
+    ##
+    def normalize_mod
+      case self
+      when /^(f|slug)/
+        :slug
+      when /^cam/
+        :camel_case
+      when /^s/
+        :snake_case
+      when /^u/
+        :uppercase
+      when /^l/
+        :lowercase
+      when /^[ct]/
+        :title_case
+      end
+    end
+
+    ##
+    ## Convert operator string to symbol
+    ##
+    ## @example "ignore" => :ignore
+    ## @example "m" => :merge
+    ##
+    ## @return     [Symbol] symbolized operator
+    ##
+    def normalize_operator
+      case self
+      # merge or append
+      when /^i/
+        :ignore
+      when /^(m|ap)/
+        :merge
+      # ask or optional
+      when /^(a|op)/
+        :ask
+      # overwrite
+      when /^o/
+        :overwrite
+      else
+        :copy
+      end
+    end
+
+    ##
+    ## Convert type string to symbol
+    ##
+    ## @example    "string".coerce #=> :string
+    ## @example    "date".coerce #=> :date
+    ## @example    "num".coerce #=> :number
+    ##
+    ## @return     [Symbol] type symbol
+    ##
+    def normalize_type
+      case self
+      # date
+      when /^da/
+        :date
+      # integer
+      when /^i/
+        :integer
+      # number or float
+      when /^[nf]/
+        :float
+      # multiline or paragraph
+      when /^(mu|p)/
+        :multiline
+      # class
+      when /^c/
+        :class
+      # module
+      when /^m/
+        :module
+      # string
+      else
+        :string
+      end
+    end
+
+    ##
+    ## Coerce a variable to a type
+    ##
+    ## @param      type  [Symbol] The type
+    ##
+    ##
+    def coerce(type)
+      case type
+      when :date
+        Chronic.parse(self)
+      when :integer || :number
+        to_i
+      when :float
+        to_f
+      when :class || :module
+        to_class_name
+      else
+        to_s
+      end
+    end
+
+    ##
+    ## Get a clean UTF-8 string by forcing an ISO encoding and then re-encoding
+    ##
+    ## @return     [String] UTF-8 string
+    ##
+    def clean_encode
+      force_encoding('ISO-8859-1').encode('utf-8', replace: nil)
+    end
+
+    ##
+    ## Destructive version of #clean_encode
+    ##
+    ## @return     [String] UTF-8 string, in place
+    ##
+    def clean_encode!
+      replace clean_encode
+    end
+
+    ##
+    ## Highlight characters in parenthesis, with special color for default if
+    ## provided. Output is color templated string, unprocessed.
+    ##
+    ## @param      default  [String] The default
+    ##
+    def highlight_character(default: nil)
+      if default
+        gsub(/\((#{default})\)/, '{dw}({xbc}\1{dw}){xw}').gsub(/\((.)\)/, '{dw}({xbw}\1{dw}){xw}')
+      else
+        gsub(/\((.)\)/, '{dw}({xbw}\1{dw}){xw}')
+      end
+    end
+  end
+end

data/lib/planter/symbol.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Symbol helpers
+class ::Symbol
+  # Handle calling to_var on a Symbol
+  #
+  # @return     [Symbol] same symbol, normalized if needed
+  #
+  def to_var
+    to_s.to_var
+  end
+
+  # Handle calling normalize_type on a Symbol
+  #
+  # @return     [Symbol] same symbol, normalized if needed
+  #
+  def normalize_type
+    to_s.normalize_type
+  end
+
+  # Handle calling normalize_operator on a Symbol
+  #
+  # @return     [Symbol] same symbol, normalized if needed
+  #
+  def normalize_operator
+    to_s.normalize_operator
+  end
+end

data/lib/planter/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Primary module for this gem.
+module Planter
+  # Current Planter version.
+  VERSION = '0.0.3'
+end

data/lib/planter.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'shellwords'
+require 'json'
+require 'yaml'
+require 'fileutils'
+require 'open3'
+
+require 'chronic'
+require 'tty-reader'
+require 'tty-screen'
+require 'tty-spinner'
+require 'tty-which'
+
+require_relative 'planter/version'
+require_relative 'planter/hash'
+require_relative 'planter/array'
+require_relative 'planter/symbol'
+require_relative 'planter/file'
+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/plant'
+
+# Main Journal module
+module Planter
+  # Base directory for templates
+  BASE_DIR = File.expand_path('~/.config/planter/')
+
+  class << self
+    include Color
+    include Prompt
+
+    ## Debug mode
+    attr_accessor :debug
+
+    ## Target
+    attr_accessor :target
+
+    ## Overwrite files
+    attr_accessor :overwrite
+
+    ## Current date
+    attr_accessor :date
+
+    ## Template name
+    attr_accessor :template
+
+    ## Config Hash
+    attr_reader :config
+
+    ## Variable key/values
+    attr_accessor :variables
+
+    ## Filter patterns
+    attr_writer :patterns
+
+    ## Accept all defaults
+    attr_accessor :accept_defaults
+
+    ##
+    ## Print a message on the command line
+    ##
+    ## @param      string             [String] The message string
+    ## @param      notification_type  [Symbol] The notification type (:debug, :error, :warn, :info)
+    ## @param      exit_code          [Integer] If provided, exit with code after delivering message
+    ##
+    def notify(string, notification_type = :info, exit_code: nil)
+      case notification_type
+      when :debug
+        warn "\n{dw}#{string}{x}".x if @debug
+      when :error
+        warn "{br}#{string}{x}".x
+      when :warn
+        warn "{by}#{string}{x}".x
+      else
+        warn "{bw}#{string}{x}".x
+      end
+
+      Process.exit exit_code unless exit_code.nil?
+    end
+
+    ##
+    ## Global progress indicator reader, will init if nil
+    ##
+    ## @return     [TTY::Spinner] Spinner object
+    ##
+    def spinner
+      @spinner ||= TTY::Spinner.new('{bw}[{by}:spinner{bw}] {w}:title'.x,
+                                    hide_cursor: true,
+                                    format: :dots,
+                                    success_mark: '{bg}✔{x}'.x,
+                                    error_mark: '{br}✖{x}'.x)
+    end
+
+    ##
+    ## Build a configuration from template name
+    ##
+    ## @param      template  [String] The template name
+    ##
+    ## @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')
+
+      unless File.exist?(base_config)
+        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)
+      end
+
+      @config = YAML.load(IO.read(base_config)).symbolize_keys
+
+      base_dir = File.join(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)
+
+        raise Errors::InputError.new('Canceled') unless res
+
+        FileUtils.mkdir_p(base_dir)
+      end
+
+      load_template_config
+
+      config_array_to_hash(:files) if @config[:files].is_a?(Array)
+      config_array_to_hash(:replacements) if @config[:replacements].is_a?(Array)
+    rescue Psych::SyntaxError => e
+      raise Errors::ConfigError.new "Parse error in configuration file:\n#{e.message}"
+    end
+
+    ##
+    ## Load a template-specific configuration
+    ##
+    ## @return     [Hash] updated config object
+    ##
+    def load_template_config
+      base_dir = File.join(BASE_DIR, 'templates', @template)
+      config = File.join(base_dir, '_planter.yml')
+
+      unless File.exist?(config)
+        default_config = {
+          variables: [
+            key: 'var_key',
+            prompt: 'CLI Prompt',
+            type: '[string, float, integer, number, date]',
+            value: '(optional, for date type can be today, time, now, etc., empty to prompt)',
+            default: '(optional default value, leave empty or remove key for no default)',
+            min: '(optional, for number type set a minimum value)',
+            max: '(optional, for number type set a maximum value)'
+          ],
+          git_init: false,
+          files: { '*.tmp' => 'ignore' }
+        }
+        File.open(config, 'w') { |f| f.puts(YAML.dump(default_config.stringify_keys)) }
+        puts "New configuration written to #{config}, please edit."
+        Process.exit 0
+      end
+      @config = @config.deep_merge(YAML.load(IO.read(config)).symbolize_keys)
+    end
+
+    ##
+    ## Convert an errant array to a hash
+    ##
+    ## @param      key   [Symbol] The key in @config to convert
+    ##
+    def config_array_to_hash(key)
+      files = {}
+      @config[key].each do |k, v|
+        files[k] = v
+      end
+      @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
+    ##
+    def process_patterns
+      patterns = {}
+      @config[:files].each do |file, oper|
+        pattern = Regexp.new(".*?/#{file.to_s.sub(%r{^/}, '').gsub(/\./, '\.').gsub(/\*/, '.*?').gsub(/\?/, '.')}$")
+        operator = oper.normalize_operator
+        patterns[pattern] = operator
+      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

@@ -0,0 +1,48 @@
+lib = File.expand_path(File.join('..', 'lib'), __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'planter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'planter-cli'
+  spec.version       = Planter::VERSION
+  spec.authors       = ['Brett Terpstra']
+  spec.email         = ['me@brettterpstra.com']
+  spec.description   = 'Plant a file and directory structure'
+  spec.summary       = 'Plant files and directories using templates'
+  spec.homepage      = 'https://github.com/ttscoff/planter-cli'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(features|spec|test)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.add_development_dependency 'bump', '~> 0.10'
+  spec.add_development_dependency 'bundler', '~> 2.2'
+  spec.add_development_dependency 'rake', '~> 13.0'
+
+  spec.add_development_dependency 'guard', '~> 2.11'
+  spec.add_development_dependency 'guard-rspec', '~> 4.5'
+  spec.add_development_dependency 'guard-rubocop', '~> 1.2'
+  spec.add_development_dependency 'guard-yard', '~> 2.1'
+
+  spec.add_development_dependency 'cli-test', '~> 1.0'
+  spec.add_development_dependency 'fuubar', '~> 2.0'
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rubocop', '>= 1.50'
+  spec.add_development_dependency 'rubocop-rake', '>= 0.6.0'
+  spec.add_development_dependency 'rubocop-rspec', '>= 2.20.0'
+  spec.add_development_dependency 'simplecov', '~> 0.9'
+
+  spec.add_development_dependency 'github-markup', '~> 1.3'
+  spec.add_development_dependency 'redcarpet', '~> 3.2'
+  spec.add_development_dependency 'yard', '~> 0.9.5'
+
+  spec.add_runtime_dependency 'chronic', '~> 0.10'
+  spec.add_runtime_dependency 'tty-reader', '~> 0.9'
+  spec.add_runtime_dependency 'tty-screen', '~> 0.8'
+  spec.add_runtime_dependency 'tty-spinner', '~> 0.9'
+  spec.add_runtime_dependency 'tty-which', '~> 0.5'
+end