envo 0.1.0

data/lib/envo/cmd_run.rb

@@ -0,0 +1,68 @@
+module Envo
+  class CmdRun
+    Name = 'run'
+    def self.register_help(help)
+      help.add_cmd 'run <script>', <<~EOF
+        run a script of envo commands
+        if script is a relative or an absolute path, it tries to load the exact filename
+        otherwise it searches for '<script>.envoscript' in .envo/ subdirs of current tree and in <home>/.envo/
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.register_script_parser(parser)
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts(args)
+      raise Envo::Error.new "run: provide a single script name. Use 'run <script>'" if args.size != 1
+      ParsedCmd.new(CmdRun.new(args[0]), opts)
+    end
+
+    def initialize(script)
+      @script = script
+    end
+
+    attr_reader :script
+
+    module Opts
+      extend self
+      def parse_script(opt)
+        case opt
+        when 'force' then return {interact: :force}
+        when 'no-force' then return {interact: :noforce}
+        when 'interactive' then return {interact: :interact}
+        when 'raw' then return {raw: true}
+        else raise Envo::Error.new "script option: #{opt}"
+        end
+      end
+    end
+
+    def execute(ctx)
+      file = ctx.find_script(@script)
+      lines = ctx.load_script(file)
+      parser = ScriptParser.new(Opts)
+
+      [
+        CmdShow,
+        CmdSet,
+        CmdReset,
+        CmdUnset,
+        CmdList,
+        CmdClean,
+        CmdCopy,
+        CmdSwap,
+        CmdPath,
+        CmdRun,
+      ].each { |cmd| cmd.register_script_parser(parser) }
+
+      res = parser.parse(lines)
+
+      scope = ctx.new_scope({interact: :force})
+      scope.execute(res)
+    end
+  end
+end

data/lib/envo/cmd_set.rb

@@ -0,0 +1,76 @@
+module Envo
+  class CmdSet
+    Name = 'set'
+    def self.register_help(help)
+      help.add_cmd "set <name>=<val>", <<~EOF
+        set a value to an environment variable
+        'set name=' unsets the value
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_tokens(tokens, opts) })
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts(args)
+      parse_tokens(args, opts)
+    end
+
+    def self.parse_tokens(args, opts)
+      # find first instance of equals
+      i = args.find_index { |arg| arg =~ /=/ }
+      raise Envo::Error.new "set: missing '='. Use 'set <name> = <val>'" if !i
+
+      elem = args[i]
+      eq_i = elem.index('=')
+
+      first = elem[0...eq_i]
+      second = elem[eq_i+1..]
+      split = [first, '=', second].select { |s| !s.empty? }
+
+      args[i..i] = split
+
+      i = args.index('=')
+      raise Envo::Error.new "set: bad name '#{args[0...i].join(' ')}'. Use 'set <name> = <val>'" if i != 1
+
+      return ParsedCmd.new(CmdUnset.new([args[0]]), opts) if args.size == 2
+
+      ParsedCmd.new(CmdSet.new(args[0], args[2..]), opts)
+    end
+
+    def self.parse_script(args)
+      puts "#{Name} parse_script"
+    end
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    attr_accessor :name, :value
+
+    def execute(ctx)
+      ename = ctx.expand_name(@name)
+      new_val = ctx.expand_value(@value)
+
+      old_val = ctx.smart_get(ename)
+
+      ok = old_val.type == new_val.type
+      ok ||= old_val.accept_assign?(new_val)
+      ok ||= ctx.ask("Assign #{new_val.type} to #{old_val.type}?")
+      raise Envo::Error.new "set: assignment of #{new_val.type} to #{old_val.type}" if !ok
+
+      idesc = new_val.invalid_description
+      ok = !idesc
+      ok ||= ctx.ask("Assign #{idesc} to #{ename}?")
+      raise Envo::Error.new "set: assignment of #{idesc} to #{ename}" if !ok
+
+      ctx.smart_set(ename, new_val)
+    end
+  end
+end

data/lib/envo/cmd_show.rb

@@ -0,0 +1,82 @@
+module Envo
+  class CmdShow
+    Name = 'show'
+    def self.register_help(help)
+      help.add_cmd "show <name> ...", <<~EOF
+        show values of environment variables
+          --name - display the name of the variable along with the value
+          shorhand: 's'
+      EOF
+
+      help.add_cmd 'rshow <name> ...', <<~EOF
+        show the *raw* value of environment variables with no pretty prints
+        a shortcut to 'show --raw <name> ...'
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd('show', ->(cmd, args) { parse_cli(args) })
+      parser.add_cmd('s', ->(cmd, args) { parse_cli(args) })
+      parser.add_cmd('rshow', ->(cmd, args) { parse_cli(args + ['--raw']) })
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_script(tokens, opts) })
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts(args)
+      show_names = false
+      opts.filter! do |opt|
+        if opt == '--name'
+          show_names = true
+          false
+        else
+          true
+        end
+      end
+      ParsedCmd.new(CmdShow.new(args, show_names), opts)
+    end
+
+    def self.parse_script(tokens, opts)
+      show_names = false
+      opts.filter! do |opt|
+        if opt == 'name'
+          show_names = true
+          false
+        else
+          true
+        end
+      end
+      ParsedCmd.new(CmdShow.new(tokens, show_names), opts)
+    end
+
+    def initialize(names, show_names)
+      raise Error.new 'show: no names provided' if names.empty?
+      @names = names
+      @show_names = show_names
+    end
+
+    attr_reader :names, :show_names
+
+    def execute(ctx)
+      @names.each do |name|
+        ename = ctx.expand_name(name)
+
+        pname = show_names ? "#{ename}=" : ''
+
+        if ctx.raw?
+          ctx.puts("#{pname}#{ctx.raw_get(ename)}")
+        else
+          val = ctx.smart_get(ename)
+          if val.type == :empty
+            ctx.puts("No var with name #{ename}")
+          else
+            ctx.print(pname)
+            val.pretty_print(ctx)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/envo/cmd_swap.rb

@@ -0,0 +1,49 @@
+module Envo
+  class CmdSwap
+    Name = 'swap'
+    def self.register_help(help)
+      help.add_cmd 'swap <name1> <name2>', "swap values of two environment variables"
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_tokens(tokens, opts) })
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts(args)
+      parse_tokens(args, opts)
+    end
+
+    def self.parse_tokens(args, opts)
+      raise Envo::Error.new "swap: provide two names to swap. Use 'swap <name1> <name2>'" if args.size != 2
+      ParsedCmd.new(CmdSwap.new(args[0], args[1]), opts)
+    end
+
+    def initialize(name_a, name_b)
+      @name_a = name_a
+      @name_b = name_b
+    end
+
+    attr_accessor :name_a, :name_b
+
+    def execute(ctx)
+      ea = ctx.expand_name(@name_a)
+      raw_a = ctx.raw_get(ea)
+      raise Envo::Error.new "swap: no such var '#{ea}'" if !raw_a && !ctx.force?
+
+      eb = ctx.expand_name(@name_b)
+      raw_b = ctx.raw_get(eb)
+      raise Envo::Error.new "swap: no such var '#{eb}'" if !raw_b && !ctx.force?
+
+      return if ea == eb # swap something with itself...
+      return if !raw_a && !raw_b # no point in doing anything if they don't exist
+
+      ctx.raw_set(ea, raw_b)
+      ctx.raw_set(eb, raw_a)
+    end
+  end
+end

data/lib/envo/cmd_unset.rb

@@ -0,0 +1,45 @@
+module Envo
+  class CmdUnset
+    Name = 'unset'
+    def self.register_help(help)
+      help.add_cmd 'unset <name> ...', "unset values of one or more environment variables"
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_tokens(tokens, opts) })
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts(args)
+      ParsedCmd.new(CmdUnset.new(args), opts)
+    end
+
+    def self.parse_tokens(tokens, opts)
+      ParsedCmd.new(CmdUnset.new(tokens), opts)
+    end
+
+    def initialize(names)
+      raise Envo::Error.new 'unset: no names provided' if names.empty?
+      @names = names
+    end
+
+    attr_reader :names
+
+    def execute(ctx)
+      @names.each do |name|
+        ename = ctx.expand_name(name)
+        raw_old_val = ctx.raw_get(ename)
+
+        if raw_old_val
+          ctx.unset(ename)
+        else
+          raise Envo::Error.new "unset: no such var '#{ename}'" if !ctx.force?
+        end
+      end
+    end
+  end
+end

data/lib/envo/context.rb

@@ -0,0 +1,156 @@
+module Envo
+  class Context
+    def initialize(host, log, opts, state = nil)
+      @host = host
+      @log = log
+      @default_opts = opts
+      @opts = opts
+      reflect_opts_change
+
+      @state = state || State.new(host.env)
+
+      create_common_locals
+    end
+
+    attr_reader :host, :state
+
+    # create another context based on this one (same state, log, and host)
+    # which provides different opts an locals
+    # thus scripts can be executed which don't leak values in the scope above
+    def new_scope(defaults = {})
+      Context.new(@host, @log, @opts.merge(defaults), @state)
+    end
+
+    def find_script(script)
+      if @host.shell.likely_rel_path?(script) || @host.shell.likely_abs_path?(script)
+        return script if @host.path_exists?(script)
+        raise Envo::Error.new "'#{script}' doesn't exist"
+      end
+
+      # look for '.envo/<file>.envoscript'
+      script = script + '.envoscript'
+      dir = @host.pwd
+      found = while true
+        check = File.join(dir, '.envo', script)
+        break check if @host.path_exists?(check)
+        new_dir = File.dirname(dir)
+        break nil if new_dir == dir
+        dir = new_dir
+      end
+
+      if !found
+        check = File.join(@host.home, '.envo', script)
+        found = check if @host.path_exists?(check)
+      end
+
+      raise Envo::Error.new "Can't find '#{script}' in .envo/ parent dirs or in <home>/.envo/" if !found
+      found
+    end
+
+    def load_script(path)
+      File.readlines(path)
+    end
+
+    # parse access
+    def expand_name(name)
+      @locals[name] || name
+    end
+    def expand_value(val)
+      if raw?
+        if val.class == Array
+          if val.size == 1
+            StringVal.new(val[0])
+          else
+            ListVal.new(val)
+          end
+        else
+          StringVal.new(val)
+        end
+      else
+        ValBuilder.from_user_text(val, @host)
+      end
+    end
+    # local vars
+    def local_var_name?(name)
+      name =~ /^@[a-zA-Z]/
+    end
+    def set_local_var(name, value)
+      @locals[name] = value
+    end
+    def create_common_locals
+      @locals = {
+        '@path' => host.shell.path_var_name,
+        '@home' => host.shell.home_var_name,
+      }
+    end
+
+    # env access
+    def smart_get(name)
+      ValBuilder.from_env_string(raw_get(name), @host)
+    end
+    def raw_get(name)
+      @state.get(name)
+    end
+
+    def smart_set(name, value)
+      if value.list?
+        rv = @host.shell.ar_to_list(value.ar)
+        raw_set(name, rv)
+      else
+        raw_set(name, value.to_env_s)
+      end
+    end
+    def raw_set(name, value)
+      @state.set(name, value)
+    end
+
+    def unset(name)
+      @state.unset(name)
+    end
+
+    # opt queries
+    def raw?
+      @opts[:raw]
+    end
+    def force?
+      @opts[:interact] == :force
+    end
+    def noforce?
+      @opts[:interact] == :noforce
+    end
+    def interact?
+      @opts[:interact] == :interact
+    end
+
+    def reflect_opts_change
+      @log.max_level = @opts[:log_level]
+    end
+
+    # io
+    def ask(question)
+      return true if force?
+      return false if noforce?
+
+      print "#{question} (y/n): "
+      answer = STDIN.gets.chomp
+      answer.downcase!
+      return answer == 'y' || answer == 'yes'
+    end
+
+    def error(text); @log.error(text); end
+    def warn(text);  @log.warn(text); end
+    def print(text); @log.print(text); end
+    def puts(text);  @log.puts(text); end
+    def debug(text); @log.debug(text); end
+
+    # execution
+    def execute(pack)
+      pack_opts = pack.opts
+      pack.cmds.each do |cmd|
+        @opts = @default_opts.merge(cmd.opts, pack_opts)
+        reflect_opts_change
+        cmd.cmd.execute(self)
+      end
+    end
+  end
+end