planter-cli 0.0.3

data/bin/plant

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$VERBOSE = true
+
+require 'optparse'
+require_relative '../lib/planter'
+
+options = {
+  help: false,
+  debug: false,
+  version: false
+}
+
+# Variable definition
+# variables:
+# - key: var
+#   prompt: Variable
+#   type: [string,float,integer,number,date]
+#   value: (for date type can be today, time, now, etc.)
+#   default: Untitled
+#   min: 1
+#   max: 5
+Planter.variables = {}
+Planter::Color.coloring = $stdout.isatty
+
+opts = OptionParser.new
+opts.banner = 'Usage: planter [options] TEMPLATE'
+
+Planter.accept_defaults = false
+opts.on('--defaults', 'Accept default values for all variables') do
+  Planter.accept_defaults = true
+end
+
+Planter.target = Dir.pwd
+opts.on('-i', '--in TARGET', 'Plant in TARGET instead of current directory') do |opt|
+  target = File.expand_path(opt)
+  FileUtils.mkdir_p(target) unless File.exist?(target)
+  Planter.target = target
+end
+
+opts.on('-k', '--var=KEY:VALUE,KEY:VALUE...', Array,
+        'Pass a variable on the command line as KEY:VALUE pairs. Can be used multiple times.') do |opt|
+  opt.each do |o|
+    parts = o.split(/:/)
+    key = parts.shift
+    value = parts.join(':')
+    Planter.variables[key.to_var] = value
+  end
+end
+
+opts.on('-o', '--overwrite', 'Overwrite existing files') do
+  Planter.overwrite = true
+end
+
+opts.on_tail('-d', '--debug', 'Display version number') do
+  Planter.debug = true
+end
+
+opts.on_tail('-h', '--help', 'Display this screen, or list variables for template argument') do
+  options[:help] = true
+end
+
+opts.on_tail('-v', '--version', 'Display version number') do
+  options[:version] = true
+end
+
+opts.parse!
+
+##
+## List variables for a template
+##
+## @param      template  [String] The template
+##
+def list_vars(template)
+  puts "#{template} variables:"
+  Planter.config = template
+  Planter.config[:variables].sort_by { |v| v[:key].to_var }.each do |var|
+    title = var[:prompt] || var[:key]
+    var_type = var[:type].normalize_type || :string
+    default = var[:value] || var[:default]
+    default = default ? ", default: #{default.coerce(var_type)}" : ''
+    puts "#{title}:"
+    puts "  [#{var[:key].to_var}] (type: #{var_type}#{default})"
+  end
+end
+
+if options[:version]
+  puts "planter v#{Planter::VERSION}"
+  Process.exit 0
+elsif options[:help]
+  if ARGV.count.zero?
+    puts opts
+  else
+    list_vars(ARGV[0])
+  end
+  Process.exit 0
+elsif ARGV.count.zero?
+  raise Planter::Errors::ArgumentError.new 'Template argument required'
+end
+
+ARGV.each do |template|
+  Planter.config = template
+  app = Planter::Plant.new
+  app.plant
+end

data/docker/Dockerfile

@@ -0,0 +1,12 @@
+FROM ruby:3.0.1
+# RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
+RUN mkdir /planter
+WORKDIR /planter
+
+RUN gem install bundler:2.2.29
+RUN apt-get update -y
+RUN apt-get install -y less vim
+COPY ./docker/inputrc /root/.inputrc
+COPY ./docker/bash_profile /root/.bash_profile
+RUN mkdir -p /root/.config/planter/templates/test
+CMD ["/planter/scripts/runtests.sh"]

data/docker/Dockerfile-2.6

@@ -0,0 +1,12 @@
+FROM ruby:2.6
+# RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
+RUN mkdir /howzit
+WORKDIR /howzit
+# COPY ./ /howzit/
+RUN gem install bundler:2.2.29
+RUN apt-get update -y
+RUN apt-get install -y less vim
+COPY ./docker/inputrc /root/.inputrc
+COPY ./docker/bash_profile /root/.bash_profile
+RUN mkdir -p /root/.config/planter/templates/test
+CMD ["/planter/scripts/runtests.sh"]

data/docker/Dockerfile-2.7

@@ -0,0 +1,12 @@
+FROM ruby:2.7
+# RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
+RUN mkdir /howzit
+WORKDIR /howzit
+# COPY ./ /howzit/
+RUN gem install bundler:2.2.29
+RUN apt-get update -y
+RUN apt-get install -y less vim
+COPY ./docker/inputrc /root/.inputrc
+COPY ./docker/bash_profile /root/.bash_profile
+RUN mkdir -p /root/.config/planter/templates/test
+CMD ["/planter/scripts/runtests.sh"]

data/docker/Dockerfile-3.0

@@ -0,0 +1,11 @@
+FROM ruby:3.0.0
+# RUN curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
+RUN mkdir /howzit
+WORKDIR /howzit
+# COPY ./ /howzit/
+RUN gem install bundler:2.2.29
+RUN apt-get update -y
+RUN apt-get install -y less vim
+COPY ./docker/inputrc /root/.inputrc
+COPY ./docker/bash_profile /root/.bash_profile
+CMD ["/planter/scripts/runtests.sh"]

data/docker/bash_profile

@@ -0,0 +1,15 @@
+#!/bin/bash
+export GLI_DEBUG=true
+export EDITOR="/usr/bin/vim"
+alias b="bundle exec bin/plant"
+alias quit="exit"
+
+shopt -s nocaseglob
+shopt -s histappend
+shopt -s histreedit
+shopt -s histverify
+shopt -s cmdhist
+
+cd /planter
+bundle install
+gem install pkg/*.gem

data/docker/inputrc

@@ -0,0 +1,57 @@
+"\e[3~": delete-char
+"\ex": 'cd !$ \015ls\015'
+"\ez": 'cd -\015'
+"\e\C-m": '\C-a "$(\C-e|fzf)"\C-a'
+"\e/": '"$(!!|fzf)"\C-a \C-m\C-m'
+# these allow you to use alt+left/right arrow keys
+# to jump the cursor over words
+"\e[1;5C": forward-word
+"\e[1;5D": backward-word
+# "\e[D": backward-word
+# "\e[C": forward-word
+"\ea": menu-complete
+# TAB: menu-complete
+# "\e[Z": "\e-1\C-i"
+
+"\e\C-l": history-and-alias-expand-line
+
+# these allow you to start typing a command and
+# use the up/down arrow to auto complete from
+# commands in your history
+"\e[B": history-search-forward
+"\e[A": history-search-backward
+"\ew": history-search-backward
+"\es": history-search-forward
+# this lets you hit tab to auto-complete a file or
+# directory name ignoring case
+set completion-ignore-case On
+set mark-symlinked-directories On
+set completion-prefix-display-length 2
+set bell-style none
+# set bell-style visible
+set meta-flag on
+set convert-meta off
+set input-meta on
+set output-meta on
+set show-all-if-ambiguous on
+set show-all-if-unmodified on
+set completion-map-case on
+set visible-stats on
+
+# Do history expansion when space entered?
+$if bash
+	Space: magic-space
+$endif
+
+# Show extra file information when completing, like `ls -F` does
+set visible-stats on
+
+# Be more intelligent when autocompleting by also looking at the text after
+# the cursor. For example, when the current line is "cd ~/src/mozil", and
+# the cursor is on the "z", pressing Tab will not autocomplete it to "cd
+# ~/src/mozillail", but to "cd ~/src/mozilla". (This is supported by the
+# Readline used by Bash 4.)
+set skip-completed-text on
+
+# Use Alt/Meta + Delete to delete the preceding word
+"\e[3;3~": kill-word

data/lib/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: ../.rubocop.yml

data/lib/planter/array.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Planter
+  # Array helpers
+  class ::Array
+    ##
+    ## Convert an array of "(c)hoices" to abbrevation. If a default character is
+    ## provided it will be highlighted. Output is a color template, unprocessed.
+    ##
+    ## @example    ["(c)hoice", "(o)ther"].abbr_choices #=> "[c/o]"
+    ##
+    ## @param      default  [String] The color templated output string
+    ##
+    def abbr_choices(default: nil)
+      chars = join(' ').scan(/\((.)\)/).map { |c| c[0] }
+      out = String.new
+      out << '{xdw}['
+      out << chars.map do |c|
+        if default && c.downcase == default.downcase
+          "{xbc}#{c}"
+        else
+          "{xbw}#{c}"
+        end
+      end.join('{dw}/')
+      out << '{dw}]{x}'
+    end
+  end
+end

data/lib/planter/color.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+module Planter
+  # Cribbed from <https://github.com/flori/term-ansicolor>
+  # Terminal output color functions.
+  module Color
+    # Regexp to match excape sequences
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/
+
+    # All available color names. Available as methods and string extensions.
+    #
+    # @example Use a color as a method. Color reset will be added to end of string.
+    #   Color.yellow('This text is yellow') => "\e[33mThis text is yellow\e[0m"
+    #
+    # @example Use a color as a string extension. Color reset added automatically.
+    #   'This text is green'.green => "\e[1;32mThis text is green\e[0m"
+    #
+    # @example Send a text string as a color
+    #   Color.send('red') => "\e[31m"
+    ATTRIBUTES = [
+      [:clear, 0], # String#clear is already used to empty string in Ruby 1.9
+      [:reset, 0], # synonym for :clear
+      [:bold, 1],
+      [:dark, 2],
+      [:italic, 3], # not widely implemented
+      [:underline, 4],
+      [:underscore, 4], # synonym for :underline
+      [:blink, 5],
+      [:rapid_blink, 6], # not widely implemented
+      [:negative, 7], # no reverse because of String#reverse
+      [:concealed, 8],
+      [:strikethrough, 9], # not widely implemented
+      [:strike, 9], # not widely implemented
+      [:black, 30],
+      [:red, 31],
+      [:green, 32],
+      [:yellow, 33],
+      [:blue, 34],
+      [:magenta, 35],
+      [:purple, 35],
+      [:cyan, 36],
+      [:white, 37],
+      [:bgblack, 40],
+      [:bgred, 41],
+      [:bggreen, 42],
+      [:bgyellow, 43],
+      [:bgblue, 44],
+      [:bgmagenta, 45],
+      [:bgpurple, 45],
+      [:bgcyan, 46],
+      [:bgwhite, 47],
+      [:boldblack, 90],
+      [:boldred, 91],
+      [:boldgreen, 92],
+      [:boldyellow, 93],
+      [:boldblue, 94],
+      [:boldmagenta, 95],
+      [:boldpurple, 95],
+      [:boldcyan, 96],
+      [:boldwhite, 97],
+      [:boldbgblack, 100],
+      [:boldbgred, 101],
+      [:boldbggreen, 102],
+      [:boldbgyellow, 103],
+      [:boldbgblue, 104],
+      [:boldbgmagenta, 105],
+      [:boldbgpurple, 105],
+      [:boldbgcyan, 106],
+      [:boldbgwhite, 107],
+      [:softpurple, '0;35;40'],
+      [:hotpants, '7;34;40'],
+      [:knightrider, '7;30;40'],
+      [:flamingo, '7;31;47'],
+      [:yeller, '1;37;43'],
+      [:whiteboard, '1;30;47'],
+      [:chalkboard, '1;37;40'],
+      [:led, '0;32;40'],
+      [:redacted, '0;30;40'],
+      [:alert, '1;31;43'],
+      [:error, '1;37;41'],
+      [:default, '0;39']
+    ].map(&:freeze).freeze
+
+    # Array of attribute keys only
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+
+    # Returns true if Color supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+
+    # Template coloring
+    class ::String
+      ##
+      ## Shortcut for #template
+      ##
+      ## @return [String] colorized string
+      ##
+      def x
+        Color.template(self)
+      end
+
+      ##
+      ## Extract the longest valid %color name from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ##
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        normalize_color.chars.each do |char|
+          compiled += char
+          if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+            valid_color = compiled
+          end
+        end
+
+        valid_color
+      end
+
+      ##
+      ## Normalize a color name, removing underscores,
+      ## replacing "bright" with "bold", and converting
+      ## bgbold to boldbg
+      ##
+      ## @return     [String] Normalized color name
+      ##
+      def normalize_color
+        delete('_').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+      end
+
+      # Get the calculated ANSI color at the end of the
+      # string
+      #
+      # @return     ANSI escape sequence to match color
+      #
+      def last_color_code
+        m = scan(ESCAPE_REGEX)
+
+        em = ['0']
+        fg = nil
+        bg = nil
+        rgbf = nil
+        rgbb = nil
+
+        m.each do |c|
+          case c
+          when '0'
+            em = ['0']
+            fg, bg, rgbf, rgbb = nil
+          when /^[34]8/
+            case c
+            when /^3/
+              fg = nil
+              rgbf = c
+            when /^4/
+              bg = nil
+              rgbb = c
+            end
+          else
+            c.split(';').each do |i|
+              x = i.to_i
+              if x <= 9
+                em << x
+              elsif x >= 30 && x <= 39
+                rgbf = nil
+                fg = x
+              elsif x >= 40 && x <= 49
+                rgbb = nil
+                bg = x
+              elsif x >= 90 && x <= 97
+                rgbf = nil
+                fg = x
+              elsif x >= 100 && x <= 107
+                rgbb = nil
+                bg = x
+              end
+            end
+          end
+        end
+
+        escape = "\e[#{em.join(';')}m"
+        escape += "\e[#{rgbb}m" if rgbb
+        escape += "\e[#{rgbf}m" if rgbf
+        escape + "\e[#{[fg, bg].delete_if(&:nil?).join(';')}m"
+      end
+    end
+
+    class << self
+      # Returns true if the coloring function of this module
+      # is switched on, false otherwise.
+      def coloring?
+        @coloring
+      end
+
+      attr_writer :coloring
+
+      ##
+      ## Enables colored output
+      ##
+      ## @example Turn color on or off based on TTY
+      ##   Color.coloring = STDOUT.isatty
+      def coloring
+        @coloring ||= true
+      end
+
+      ##
+      ## Convert a template string to a colored string.
+      ## Colors are specified with single letters inside
+      ## curly braces. Uppercase changes background color.
+      ##
+      ## w: white, k: black, g: green, l: blue, y: yellow, c: cyan,
+      ## m: magenta, r: red, b: bold, u: underline, i: italic,
+      ## x: reset (remove background, color, emphasis)
+      ##
+      ## Also accepts {(#)RGB} and {(#)RRGGBB} strings. Put a b before
+      ## the hash to make it a background color
+      ##
+      ## @example Convert a templated string
+      ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
+      ##
+      ## @example Convert using RGB colors
+      ##   Color.template('{#f0a}This is an RGB color')
+      ##
+      ## @param      input  [String, Array] The template
+      ##                    string. If this is an array, the
+      ##                    elements will be joined with a
+      ##                    space.
+      ##
+      ## @return     [String] Colorized string
+      ##
+      def template(input)
+        input = input.join(' ') if input.is_a? Array
+        return input.gsub(/(?<!\\)\{(\w+)\}/i, '') unless Color.coloring?
+
+        input = input.gsub(/(?<!\\)\{((?:[fb]g?)?#[a-f0-9]{3,6})\}/i) do
+          hex = Regexp.last_match(1)
+          rgb(hex)
+        end
+
+        fmt = input.gsub(/%/, '%%')
+        fmt = fmt.gsub(/(?<!\\)\{(\w+)\}/i) do
+          Regexp.last_match(1).chars.map { |c| "%<#{c}>s" }.join('')
+        end
+
+        colors = { w: white, k: black, g: green, l: blue,
+                   y: yellow, c: cyan, m: magenta, r: red,
+                   W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                   Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                   d: dark, b: bold, u: underline, i: italic, x: reset }
+
+        format(fmt, colors)
+      end
+    end
+
+    ATTRIBUTES.each do |c, v|
+      new_method = <<-EOSCRIPT
+        # Color string as #{c}
+        def #{c}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+
+      next unless /bold/.match?(c)
+
+      # Accept brightwhite in addition to boldwhite
+      new_method = <<-EOSCRIPT
+        # color string as #{c}
+        def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+    end
+
+    ##
+    ## Generate escape codes for hex colors
+    ##
+    ## @param      hex   [String] The hexadecimal color code
+    ##
+    ## @return     [String] ANSI escape string
+    ##
+    def rgb(hex)
+      is_bg = /^bg?#/.match?(hex)
+      hex_string = hex.sub(/^([fb]g?)?#/, '')
+
+      if hex_string.length == 3
+        parts = hex_string.match(/(?<r>.)(?<g>.)(?<b>.)/)
+
+        t = []
+        %w[r g b].each do |e|
+          t << parts[e]
+          t << parts[e]
+        end
+        hex_string = t.join('')
+      end
+
+      parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
+      t = []
+      %w[r g b].each do |e|
+        t << parts[e].hex
+      end
+
+      "\e[#{is_bg ? '48' : '38'};2;#{t.join(';')}m"
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+m/
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolor(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(COLORED_REGEXP, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all Color attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/planter/errors.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Planter
+  ## Error handlers
+  module Errors
+    ## Exit codes
+    EXIT_CODES = {
+      argument: 12,
+      canceled: 1,
+      config: 127,
+      git: 129
+    }.deep_freeze
+
+    ## Argument error class
+    class InputError < StandardError
+      def initialize(msg = nil)
+        msg = msg ? "Input: #{msg}" : 'Canceled'
+
+        Planter.notify(msg, :error, exit_code: EXIT_CODES[:canceled])
+
+        super(msg)
+      end
+    end
+
+    ## Argument error class
+    class ArgumentError < StandardError
+      def initialize(msg = nil)
+        msg = msg ? "Argument error: #{msg}" : 'Argument error'
+
+        Planter.notify(msg, :error, exit_code: EXIT_CODES[:argument])
+
+        super(msg)
+      end
+    end
+
+    ## Git error class
+    class GitError < StandardError
+      def initialize(msg = nil)
+        msg = msg ? "Git: #{msg}" : 'Git error'
+
+        Planter.spinner.error('(Error)')
+        Planter.notify(msg, :error, exit_code: EXIT_CODES[:git])
+
+        super(msg)
+      end
+    end
+
+    # Configuration error class
+    class ConfigError < StandardError
+      def initialize(msg = nil)
+        msg = msg ? "Config: #{msg}" : 'Configuration error'
+        Planter.spinner.error('(Error)')
+        Planter.notify(msg, :error, exit_code: EXIT_CODES[:config])
+
+        super(msg)
+      end
+    end
+  end
+end