envo 0.1.0

data/lib/envo/error.rb

@@ -0,0 +1,7 @@
+module Envo
+  class Error < StandardError
+    def initialize(msg)
+      super
+    end
+  end
+end

data/lib/envo/host.rb

@@ -0,0 +1,24 @@
+module Envo
+  class Host
+    def initialize(shell)
+      @shell = shell
+    end
+    attr_reader :shell
+
+    def env
+      ENV
+    end
+
+    def pwd
+      Dir.pwd
+    end
+
+    def home
+      Dir.home
+    end
+
+    def path_exists?(path)
+      File.exist?(path)
+    end
+  end
+end

data/lib/envo/host_shell.rb

@@ -0,0 +1,11 @@
+module Envo
+  HostShell = -> {
+    env_shell = ENV['SHELL']
+    break Shell::WinCmd if !env_shell
+    if env_shell =~ /bash/
+      raise Error.new "bash on Windows (msys) is not supported yet" if env_shell =~ /^[a-zA-Z]\:/
+      break Shell::Bash
+    end
+    raise Error.new "Unknown shell! Please report on https://github.com/iboB/envo/issues"
+  }.()
+end

data/lib/envo/logger.rb

@@ -0,0 +1,27 @@
+module Envo
+  class Logger
+    ERROR = 0
+    WARN = 1
+    INFO = 2
+    DEBUG = 3
+    def initialize()
+      @max_level = DEBUG
+    end
+    attr_accessor :max_level
+    def log(level, text)
+      return if level > max_level
+      stream = level == 0 ? STDERR : STDOUT
+      stream.puts(text)
+    end
+    def plog(level, text)
+      return if level > max_level
+      stream = level == 0 ? STDERR : STDOUT
+      stream.print(text)
+    end
+    def error(text); log(ERROR, text); end
+    def warn(text);  log(WARN,  text); end
+    def puts(text);  log(INFO,  text); end
+    def print(text); plog(INFO, text); end
+    def debug(text); log(DEBUG, text); end
+  end
+end

data/lib/envo/parse_result.rb

@@ -0,0 +1,9 @@
+module Envo
+  class ParseResult
+    def initialize()
+      @opts = {}
+      @cmds = []
+    end
+    attr_accessor :opts, :cmds
+  end
+end

data/lib/envo/parsed_cmd.rb

@@ -0,0 +1,10 @@
+module Envo
+  class ParsedCmd
+    def initialize(cmd, opts)
+      @cmd = cmd
+      @opts = opts
+    end
+    attr_reader :cmd
+    attr_accessor :opts
+  end
+end

data/lib/envo/script_parser.rb

@@ -0,0 +1,58 @@
+require 'csv'
+
+module Envo
+  class ScriptParser
+    def initialize(opts)
+      @known_cmds = {}
+      @known_opts = opts
+    end
+    def add_cmd(name, parse_func)
+      raise Envo::Error "cmd #{name} is already added to parser" if @known_cmds[name]
+      @known_cmds[name] = parse_func
+    end
+    def parse(lines)
+      result = ParseResult.new
+
+      lines.each_with_index do |line, li|
+        li += 1
+        line.strip!
+        next if line.empty?
+        next if line[0] == '#' # comment
+
+        line_opts = if line[0] == '{' # opts pack
+          i = line.index('}')
+          raise Envo::Error.new "#{li}: malformed options pack" if !i
+          opts = line[1...i].split(',')
+          line = line[i+1..]
+          opts
+        else
+          []
+        end
+
+        raise Envo::Error.new "#{li}: missing command" if line.empty?
+
+        tokens = []
+        begin
+          tokens = CSV::parse_line(line, col_sep: ' ').compact
+        rescue
+          puts "AAAAAAA: #{line.inspect}"
+          raise Envo::Error.new "#{li}: malformed line"
+        end
+
+        raise Envo::Error.new "#{li}: missing command" if tokens.empty?
+        cmd = tokens.shift
+        raise Envo::Error.new "#{li}: unknown command '#{cmd}'" if !@known_cmds[cmd]
+        parsed_cmd = @known_cmds[cmd].(cmd, tokens, line_opts)
+
+        cmd_opts = {}
+        parsed_cmd.opts.each do |opt|
+          cmd_opts.merge! @known_opts.parse_script(opt)
+        end
+        parsed_cmd.opts = cmd_opts
+
+        result.cmds << parsed_cmd
+      end
+      result
+    end
+  end
+end

data/lib/envo/shell/bash.rb

@@ -0,0 +1,63 @@
+module Envo
+  module Shell
+    module Bash
+      extend self
+
+      def installer
+        Cli::InstallerBash
+      end
+
+      def path_var_name
+        'PATH'
+      end
+      def home_var_name
+        'HOME'
+      end
+
+      def likely_abs_path?(val)
+        !val.empty? && val[0] == '/'
+      end
+      def likely_rel_path?(val)
+        return !val.empty? && val[0] == '.'
+      end
+      def fix_path(path)
+        path
+      end
+
+      LIST_SEP = ':'
+      def likely_list?(val)
+        # we have some work
+        # if the value includes our list separtor ":", we need to make sure whether a url:port combination is not a better fit
+        return false if !val.include?(LIST_SEP)
+
+        sep_cnt = val.count(LIST_SEP)
+        return true if sep_cnt > 2
+
+        # match scheme://url
+        return false if val =~ /^\w+\:\/\//
+
+        return true if sep_cnt == 2 # everything else with 2 separators is a list
+
+        # match display type strings address:digit.digit
+        return false if val =~ /\:\d.\d$/
+
+        # match something:number to be interpreted as addr:port
+        !(val =~ /.*\:\d+$/)
+      end
+      def list_to_ar(list)
+        list.split(LIST_SEP)
+      end
+      def ar_to_list(ar)
+        ar.join(LIST_SEP)
+      end
+
+      def cmd_set_env_var(name, value)
+        escaped = value.to_s.inspect.gsub("'"){ "\\'" }
+        "export #{name}=#{escaped}"
+      end
+      def cmd_unset_env_var(name)
+        "unset -v #{name}"
+      end
+    end
+  end
+end

data/lib/envo/shell/win_cmd.rb

@@ -0,0 +1,47 @@
+module Envo
+  module Shell
+    module WinCmd
+      extend self
+
+      def installer
+        Cli::InstallerWinCmd
+      end
+
+      def path_var_name
+        'Path'
+      end
+      def home_var_name
+        'HOME'
+      end
+
+      def likely_abs_path?(val)
+        val =~ /^[a-zA-Z]\:\\/
+      end
+      def likely_rel_path?(val)
+        return !val.empty? && val[0] == '.'
+      end
+      def fix_path(path)
+        path.gsub('/', '\\')
+      end
+
+      LIST_SEP = ';'
+      def likely_list?(val)
+        val.include?(LIST_SEP)
+      end
+      def list_to_ar(list)
+        list.split(LIST_SEP)
+      end
+      def ar_to_list(ar)
+        ar.join(LIST_SEP)
+      end
+
+      def cmd_set_env_var(name, value)
+        escaped = value # TODO
+        "set #{name}=#{escaped}"
+      end
+      def cmd_unset_env_var(name)
+        "set #{name}="
+      end
+    end
+  end
+end

data/lib/envo/state.rb

@@ -0,0 +1,71 @@
+module Envo
+  class State
+    def initialize(env)
+      @real_env = env.to_h
+      @work_env = nil
+    end
+
+    attr_reader :real_env
+
+    def set(name, val)
+      if val == nil
+        unset(name)
+      else
+        work_env[name] = val.to_s
+      end
+    end
+
+    def unset(name)
+      work_env.delete(name)
+    end
+
+    def get(name)
+      work_env[name]
+    end
+
+    def work_env
+      return @work_env if @work_env
+      # if @real_env is ENV, we can use to_h to clone it into the work env
+      # however it can be an actual hash in which case to_h will return the same one
+      # and we would have to use clone
+      # so to make this work in all cases we preform a manual shallow copy
+      @work_env = @real_env.map { |k, v| [k, v] }.to_h
+    end
+
+    class Patch
+      def initialize(removed = [], changed = {}, added = {})
+        @removed = removed
+        @changed = changed
+        @added = added
+      end
+
+      def empty?
+        @removed.empty? && @changed.empty? && @added.empty?
+      end
+
+      attr_reader :removed, :changed, :added
+    end
+
+    def diff
+      return Patch.new if !@work_env
+
+      real_names = @real_env.keys
+      work_names = @work_env.keys
+
+      removed_names = real_names - work_names
+      added_names = work_names - real_names
+      preserved_names = real_names - removed_names
+
+      changed = preserved_names.map { |v|
+        r = @real_env[v]
+        w = @work_env[v]
+
+        r == w ? nil : [v, w]
+      }.compact.to_h
+
+      added = added_names.map { |v| [v, @work_env[v]] }.to_h
+
+      Patch.new(removed_names, changed, added)
+    end
+  end
+end

data/lib/envo/val/list_val.rb

@@ -0,0 +1,107 @@
+module Envo
+  class ListVal
+    def initialize(ar)
+      @ar = ar
+    end
+    attr_reader :ar
+
+    def insert(elem, pos = nil)
+      # assume unique elements
+      old_index = @ar.index(elem)
+      new_index = case pos
+        when :front then 0
+        when :back then -1
+        else old_index
+      end
+
+      return @ar << elem if !new_index
+      return @ar if new_index == old_index
+      return @ar.insert(new_index, elem) if !old_index
+
+      # we need to reorder
+      @ar.delete_at(old_index)
+      @ar.insert(new_index, elem)
+    end
+    def delete(elem)
+      @ar.delete(elem)
+    end
+    def delete_at(index)
+      @ar.delete_at(index)
+    end
+    def uniq!
+      @ar.uniq!
+    end
+    def clean!
+      uniq!
+    end
+    def shift(elem, dir)
+      i = @ar.index(elem)
+      return nil if i == nil
+      shift_at(i, dir)
+    end
+    def shift_at(i, dir)
+      return nil if i>@ar.size
+
+      if dir == :front
+        return i if i == 0
+        elem = ar[i]
+        @ar.delete_at i
+        @ar.unshift(elem)
+        0
+      elsif dir == :back
+        return i if i == (@ar.size-1)
+        elem = ar[i]
+        @ar.delete_at i
+        @ar << elem
+        @ar.size-1
+      elsif dir == :up
+        return i if i == 0
+        @ar[i-1], @ar[i] = @ar[i], @ar[i-1]
+        i - 1
+      elsif dir == :down
+        return i if i == (@ar.size-1)
+        @ar[i+1], @ar[i] = @ar[i], @ar[i+1]
+        i + 1
+      else
+        -1
+      end
+    end
+
+    def pp_attribs(elem)
+      @ar.count(elem) > 1 ? 'D' : ' '
+    end
+    def pretty_print(ctx)
+      ctx.puts "["
+      @ar.each_with_index do |v, i|
+        str = pp_attribs(v) + ' '
+        str += "#{i}:".ljust(4)
+        str += v
+        ctx.puts str
+      end
+      ctx.puts ']'
+    end
+
+    # casts
+    def type
+      :list
+    end
+    def accept_assign?(other)
+      other.list?
+    end
+    def invalid_description
+      @ar.empty? ? "empty list" : nil
+    end
+    def list?
+      true
+    end
+    def to_list
+      return self
+    end
+    def accept_item?(item)
+      true
+    end
+    def to_s
+      raise StandardError.new "list can't be converted to String"
+    end
+  end
+end