envo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54f5c8282f4d3219db6e7a5384316ed1f3fdd3e43d0e99fdfbb6d768436c8445
+  data.tar.gz: a9b2e63f76ae3dd5844694365f8dbdff259c3dcb485374583cbc258b3547a94e
+SHA512:
+  metadata.gz: 8638df6a7acbd3bd61c7ea2d717308e3369091f96585367c6fcb2c7b3c88724efc9acb93a14d3e82f9b8808a6e82cb263957290a818da64c65b16d7e945f973b
+  data.tar.gz: 63e000afd0bf3f69394c02f221b92f910714e7e29e2f53fe2d0973e9fa201b552a514f3f68ca03f84c236db0f89ffb4fc7c8c107d5e709a129bd6f3297e9a037

data/bin/envo-install

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__) # For use/testing when no gem is installed
+require 'envo'
+
+if ARGV.size == 1 && ARGV[0] == '--version'
+  puts "installer for envo v#{Envo::VERSION} #{Envo::VERSION_TYPE}"
+  exit 0
+end
+
+begin
+  shell = Envo::HostShell
+  installer = shell.installer.new
+  exit installer.run(ARGV.dup)
+rescue Envo::Error => e
+  STDERR.puts e.message
+  exit 1
+end

data/bin/envo_gen_tmp_helper.rb

@@ -0,0 +1,50 @@
+# this is the proper method
+# however we judge envo to be very low risk
+# in terms of clashes, so just do the silly thing
+# require 'securerandom'
+# fname = SecureRandom.uuid
+
+# silly thing
+fname = "envo-" + Time.now.to_i.to_s(16) + '-' + rand(1_000_000).to_s(16) + ".bat"
+# yes, simply always add the .bat extension. Linux doesn't care anyway
+
+# the ultimate multi-platform temp dir finder
+# again, the proper way would be to require 'rbconfig'
+# find the os, and use OS-specific ways, but we're trying to be fast here
+
+def temp_dirs(&block)
+  yield 'C:/windows/system32'
+  yield '/tmp' # most unixes
+  yield ENV['TMP'] # good guess for windows
+  yield '/var/tmp'
+  yield ENV['TEMP']
+  yield ENV['TEMPDIR']
+  yield Dir.home
+  yield __dir__ # why not
+  yield Dir.pwd # last resort
+end
+
+def existing_temp_dirs(&block)
+  temp_dirs do |dir|
+    yield dir if dir && File.exist?(dir)
+  end
+end
+
+existing_temp_dirs do |dir|
+  path = File.join(dir, fname)
+
+  begin
+    File.open(path, 'w') {}
+    # on windows fix path in order for 'del' to work
+    path.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+    puts path
+    exit 0
+  rescue
+    # just try the next entry
+  end
+end
+
+STDERR.puts "ERROR: Could not create envo temp file"
+# write something just so the rest can continue up to the point where this file needs to be written
+puts 'error.bat'
+exit 1

data/bin/envo_run

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+if ARGV.size == 1 && ARGV[0] == 'g'
+  require_relative 'envo_gen_tmp_helper'
+end
+
+argv = ARGV.dup
+
+if argv.size < 2 || argv.shift != 'pld'
+  STDERR.puts <<~ERR
+    envo_run needs to be called from envo
+    if you don't have the command 'envo', run 'envo-install'
+  ERR
+  exit 1
+end
+
+payload_path = argv.shift
+payload = File.open(payload_path, 'w')
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__) # For use/testing when no gem is installed
+require "envo"
+
+begin
+  host = Envo::Host.new(Envo::HostShell)
+  r = Envo::Cli::Runner.new(host, payload)
+  exit r.run(argv)
+rescue Envo::Error => e
+  STDERR.puts e.message
+  exit 1
+end

data/lib/envo.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift __dir__ # For use/testing when no gem is installed
+
+module Envo
+  autoload :VERSION, "envo/version"
+  autoload :Error, "envo/error"
+  autoload :NoVal, "envo/val/no_val"
+  autoload :StringVal, "envo/val/string_val"
+  autoload :ListVal, "envo/val/list_val"
+  autoload :PathVal, "envo/val/path_val"
+  autoload :PathListVal, "envo/val/path_list_val"
+  autoload :CmdSet, "envo/cmd_set"
+  autoload :CmdReset, "envo/cmd_reset"
+  autoload :CmdUnset, "envo/cmd_unset"
+  autoload :CmdListAdd, "envo/cmd_list_add"
+  autoload :CmdListDel, "envo/cmd_list_del"
+  autoload :CmdShow, "envo/cmd_show"
+  autoload :CmdSwap, "envo/cmd_swap"
+  autoload :CmdRun, "envo/cmd_run"
+  autoload :CmdList, "envo/cmd_list"
+  autoload :CmdPath, "envo/cmd_path"
+  autoload :CmdClean, "envo/cmd_clean"
+  autoload :CmdCopy, "envo/cmd_copy"
+  autoload :State, "envo/state"
+  autoload :ValBuilder, "envo/val/val_builder"
+  autoload :Context, "envo/context"
+  autoload :ParsedCmd, "envo/parsed_cmd"
+  autoload :CliParser, "envo/cli_parser"
+  autoload :ScriptParser, "envo/script_parser"
+  autoload :HostShell, "envo/host_shell"
+  autoload :Host, "envo/host"
+  autoload :ParseResult, "envo/parse_result"
+  autoload :Logger, "envo/logger"
+
+  module Shell
+    autoload :Bash,   'envo/shell/bash'
+    autoload :WinCmd, 'envo/shell/win_cmd'
+  end
+
+  module Cli
+    autoload :Runner, 'envo/cli/runner'
+    autoload :Help, 'envo/cli/help'
+    autoload :InstallerWinCmd, 'envo/cli/installer_win_cmd'
+    autoload :InstallerBash, 'envo/cli/installer_bash'
+  end
+end

data/lib/envo/cli/envo.bat

@@ -0,0 +1,11 @@
+@echo off
+:: we can't use `setlocal` here, since we actually WANT to leak
+:: after all, this script is supposed to set env vars
+:: however in order to get the result of `run g` we need to assign it to
+:: a local var... which we must leak :(
+:: so... just choose the a very unlikely duplicate var name
+for /f "delims=" %%A in ('envo_run g') do set _ENVO_PLD=%%A
+
+envo_run pld "%_ENVO_PLD%" %*
+call "%_ENVO_PLD%"
+del "%_ENVO_PLD%"

data/lib/envo/cli/envo.sh

@@ -0,0 +1,6 @@
+envo() {
+  local tmpfile=$(envo_run g)
+  envo_run pld "${tmpfile}" "$@"
+  source "${tmpfile}"
+  rm "${tmpfile}"
+}

data/lib/envo/cli/help.rb

@@ -0,0 +1,20 @@
+module Envo
+  module Cli
+    class Help
+      def initialize
+        @commands = []
+      end
+      def add_cmd(usage, text)
+        @commands << [usage, text]
+      end
+      def print(stream)
+        @commands.each do |cmd|
+          stream.puts "  * #{cmd[0]}"
+          cmd[1].each_line do |line|
+            stream.puts "        #{line}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/envo/cli/installer_bash.rb

@@ -0,0 +1,131 @@
+# require 'open3'
+
+module Envo
+  module Cli
+    class InstallerBash
+      # def detect_installed_envo?()
+      #   stdout, stderr, code = Open3.capture3("bash -ic 'command -v envo'")
+      #   code.success?
+      # end
+
+      ENVO_INSTALLATION_BEGIN = '### BEGIN envo installation (don\'t remove line)'
+      ENVO_INSTALLATION_END = '### END envo installation (don\'t remove line)'
+
+      def find_existing_installation_data(dotfile)
+        return nil if !File.exist?(dotfile)
+
+        raise Envo::Error.new "'#{dotfile}' exists but is not a file. You need to choose a file." if !File.file?(dotfile)
+
+        lines = File.readlines(dotfile)
+        first = nil
+        last = nil
+        lines.each_with_index do |l, i|
+          lc = l.chomp
+          if lc == ENVO_INSTALLATION_BEGIN
+            first = i
+          elsif lc == ENVO_INSTALLATION_END
+            last = i
+          end
+        end
+
+        return nil if !first && !last
+
+        if !first || !last
+          raise Envo::Error.new <<~EOF
+            #{dotfile}' contains a broken confy insallation.
+            You need to remove it manually
+          EOF
+        end
+
+        num = last - first + 1
+        return {first: first, num: num, lines: lines}
+      end
+
+      SOURCE_FILE = 'envo.sh'
+      def try_install(dotfile)
+        install_lines = [
+          ENVO_INSTALLATION_BEGIN,
+          "### envo #{VERSION}",
+          File.read(File.join(__dir__, SOURCE_FILE)),
+          ENVO_INSTALLATION_END
+        ]
+
+        found = find_existing_installation_data(dotfile)
+
+        openmode = 'a'
+        if found
+          lines = found[:lines]
+          lines[found[:first], found[:num]] = install_lines
+          install_lines = lines
+          openmode = 'w'
+        end
+
+        File.open(dotfile, openmode) { |f| f.puts install_lines }
+        puts <<~EOF
+          Sucessfully installed confy to '#{dotfile}'
+          Source the file, or restart the bash session if the file is auto-sourced.
+        EOF
+      end
+
+      def try_uninstall(dotfile)
+        found = find_existing_installation_data(dotfile)
+        if !found || found[:num] == 0
+          raise Envo::Error.new "'#{dotfile}' doesn't seem to contain an envo installation"
+        end
+
+        lines = found[:lines]
+        lines[found[:first], found[:num]] = []
+        File.open(dotfile, 'w') { |f| f.puts lines }
+        puts "Suncessfully uninstalled confy from '#{dotfile}'"
+      end
+
+      DEFAULT_DOTFILE = File.join(Dir.home, '.bashrc')
+      USAGE = <<~EOF
+        usage: envo-install [u] [--dotfile <path>]
+      EOF
+      def run(argv)
+        if argv.empty?
+          try_install(DEFAULT_DOTFILE)
+          return 0
+        end
+
+        if argv[0] == '--help' || argv[0] == '-?'
+          puts "installer for envo v#{Envo::VERSION} #{Envo::VERSION_TYPE}"
+          puts USAGE
+          puts
+          puts '                u - uninstall envo'
+          puts ' --dotfile <file> - install to or uninstall form a specified dotfile'
+          return 0
+        end
+
+        if argv[0] == 'u'
+          @uninstalling = true
+          argv.shift
+        end
+
+        dotfile = DEFAULT_DOTFILE
+        if !argv.empty?
+          arg = argv.shift
+          if arg != '--dotfile'
+            STDERR.puts "Unknown argument #{arg}"
+            STDERR.puts USAGE
+            return 1
+          end
+          if argv.empty?
+            STDERR.puts "Missing dotfile path"
+            STDERR.puts USAGE
+            return 1
+          end
+          dotfile = argv.shift
+        end
+
+        # if detect_installed_envo?
+        #   puts "It seems that you already have envo installed"
+        #   puts "Do you want to reinstall it? (y/n)"
+        # end
+        @uninstalling ? try_uninstall(dotfile) : try_install(dotfile)
+        return 0
+      end
+    end
+  end
+end

data/lib/envo/cli/installer_win_cmd.rb

@@ -0,0 +1,96 @@
+module Envo
+  module Cli
+    class InstallerWinCmd
+      def each_path_dir
+        ENV["Path"].split(';').each { |p| yield p }
+      end
+
+      ENVO_RUN_CMD = "envo_run"
+      INSTALL_FILE = "envo.bat"
+      SOURCE_FILE = "envo.bat"
+
+      def try_install(path)
+        if !path
+          each_path_dir do |dir|
+            if File.file?(File.join(dir, ENVO_RUN_CMD))
+              path = dir
+              break
+            end
+          end
+          raise Error.new("Couldn't find a good place to install envo. Please use '--path <path>' to provide one") if !path
+        end
+        raise Error.new("'#{path}' is not an existing directory") if !File.directory?(path)
+
+        src = File.read(File.join(__dir__, SOURCE_FILE))
+        target = File.join(path, INSTALL_FILE)
+        File.open(target, 'w') do |f|
+          f.puts ":: envo #{VERSION}"
+          f.write(src)
+        end
+        puts "Successfully installed #{target}"
+      end
+
+      def try_uninstall(path)
+        if path
+          file = File.join(path, INSTALL_FILE)
+          raise Error.new "Couldn't find an existing envo installation in #{path}" if !File.file?(file)
+          File.delete(file)
+          puts "Sucessfully uninstalled #{file}"
+          return
+        else
+          each_path_dir do |dir|
+            file = File.join(dir, INSTALL_FILE)
+            next if !File.file?(file)
+            File.delete(file)
+            puts "Sucessfully uninstalled #{file}"
+            return
+          end
+        end
+        raise Error.new "Couldn't find an existing envo installation to uninstall"
+      end
+
+      USAGE = <<~EOF
+        usage: envo-install [u] [--path <path>]
+      EOF
+      def run(argv)
+        if argv.empty?
+          try_install(nil)
+          return 0
+        end
+
+        if argv[0] == '--help' || argv[0] == '-?'
+          puts "installer for envo v#{Envo::VERSION} #{Envo::VERSION_TYPE}"
+          puts USAGE
+          puts
+          puts '             u - uninstall envo'
+          puts ' --path <path> - install to or uninstall form a specified directory'
+          return 0
+        end
+
+        if argv[0] == 'u'
+          @uninstalling = true
+          argv.shift
+        end
+
+        path = nil
+        if !argv.empty?
+          arg = argv.shift
+          if arg != '--path'
+            STDERR.puts "Unknown argument #{arg}"
+            STDERR.puts USAGE
+            return 1
+          end
+          if argv.empty?
+            STDERR.puts "Missing path"
+            STDERR.puts USAGE
+            return 1
+          end
+          path = argv.shift
+        end
+
+        @uninstalling ? try_uninstall(path) : try_install(path)
+        return 0
+      end
+    end
+  end
+end

data/lib/envo/cli/runner.rb

@@ -0,0 +1,129 @@
+module Envo
+  module Cli
+    class Runner
+      def initialize(host, payload)
+        @host = host
+        @payload = payload
+      end
+      attr_reader :host, :payload
+
+      VERSION_TEXT = "envo v#{Envo::VERSION} #{Envo::VERSION_TYPE}"
+      USAGE = <<~EOF
+        usage: envo [--version] [--help] <command> [<args>]
+      EOF
+
+      module Opts
+        extend self
+        def parse_cli(opt)
+          case opt
+          when '--force', '-f' then return {interact: :force}
+          when '--no-force', '-nf' then return {interact: :noforce}
+          when '--interactive' then return {interact: :interact}
+          when '--raw', '-r' then return {raw: true}
+          else raise Envo::Error.new "unknown command line option: #{opt}"
+          end
+        end
+        def print_arg(log, arg, text)
+          log.puts "    #{arg.ljust(15)} - #{text}"
+        end
+        def print_help(log)
+          print_arg log, '--force, -f', 'force the execution of the command disregarding checks'
+          print_arg log, '--interactive', '(default) ask a question when a check fails'
+          print_arg log, '--no-force, -nf', 'produce an error instead of asking questions for checks'
+          print_arg log, '--raw, -r', 'don\'t infer types and treat each value as a raw string'
+        end
+        Defaults = {
+          interact: :interact,
+          log_level: Logger::INFO
+        }
+      end
+
+      Commands = [
+        CmdShow,
+        CmdSet,
+        CmdReset,
+        CmdUnset,
+        CmdList,
+        CmdListAdd,
+        CmdListDel,
+        CmdClean,
+        CmdCopy,
+        CmdSwap,
+        CmdPath,
+        CmdRun,
+      ]
+
+      def print_version
+        @log.puts VERSION_TEXT
+      end
+
+      def print_help
+        print_version
+        @log.puts USAGE
+        @log.puts ''
+        @log.puts 'Commands:'
+        help = Help.new
+        Commands.each do |cmd|
+          cmd.register_help(help)
+        end
+        help.print(@log)
+        @log.puts ''
+        @log.puts 'Common options:'
+        Opts.print_help(@log)
+      end
+
+      def check_help_ver(argv)
+        raise Error.new USAGE if argv.empty?
+        case argv[0]
+        when '--help', '-h', '-?'
+          print_help
+          true
+        when '--version'
+          print_version
+          true
+        else
+          false
+        end
+      end
+
+      def do_run(argv)
+        return if check_help_ver(argv)
+
+        parser = CliParser.new(Opts)
+        Commands.each { |cmd| cmd.register_cli_parser(parser) }
+        parsed = parser.parse(argv)
+
+        ctx = Context.new(@host, @log, Opts::Defaults)
+        ctx.execute(parsed)
+
+        patch = ctx.state.diff
+
+        return if patch.empty?
+
+        patch.removed.each { |name|
+          @payload.puts @host.shell.cmd_unset_env_var(name)
+          puts @host.shell.cmd_unset_env_var(name)
+        }
+        patch.changed.each { |name, val|
+          @payload.puts @host.shell.cmd_set_env_var(name, val)
+          puts @host.shell.cmd_set_env_var(name, val)
+        }
+        patch.added.each { |name, val|
+          @payload.puts @host.shell.cmd_set_env_var(name, val)
+          puts @host.shell.cmd_set_env_var(name, val)
+        }
+      end
+
+      def run(argv)
+        @log = Logger.new
+        begin
+          do_run(argv)
+          return 0
+        rescue Error => e
+          @log.error e.message
+          return 1
+        end
+      end
+    end
+  end
+end