envo 0.1.0

data/lib/envo/cli_parser.rb

@@ -0,0 +1,54 @@
+module Envo
+  class CliParser
+    def self.opt?(opt)
+      opt =~ /^-/
+    end
+    def self.filter_opts_front(args)
+      front_opts = args.take_while { |a| opt?(a) }
+      args.shift(front_opts.size)
+      front_opts
+    end
+    def self.filter_opts_back(args)
+      back_opts = args.reverse.take_while { |a| opt?(a) }.reverse
+      args.pop(back_opts.size)
+      back_opts
+    end
+    def self.filter_opts(args)
+      filter_opts_front(args) + filter_opts_back(args)
+    end
+    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(argv)
+      result = ParseResult.new
+      cmd = nil
+      while !argv.empty?
+        arg = argv.shift
+        if CliParser.opt?(arg)
+          result.opts.merge! @known_opts.parse_cli(arg)
+        else
+          break cmd = arg
+        end
+      end
+
+      raise Envo::Error.new 'missing command' if !cmd
+      raise Envo::Error.new "unknown command '#{cmd}'" if !@known_cmds[cmd]
+
+      parsed_cmd = @known_cmds[cmd].(cmd, argv)
+
+      cmd_opts = {}
+      parsed_cmd.opts.each do |opt|
+        cmd_opts.merge! @known_opts.parse_cli(opt)
+      end
+      parsed_cmd.opts = cmd_opts
+
+      result.cmds << parsed_cmd
+      result
+    end
+  end
+end

data/lib/envo/cmd_clean.rb

@@ -0,0 +1,53 @@
+module Envo
+  class CmdClean
+    Name = 'clean'
+    def self.register_help(help)
+      help.add_cmd "clean <name> ...", <<~EOF
+        cleans environent variables
+        unsets empty strings, non-existing paths, empty lists
+        removes duplicates from lists and non-existing paths from path lists
+      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(tokens, opts)
+      ParsedCmd.new(CmdClean.new(tokens), opts)
+    end
+
+    def initialize(names)
+      raise Error.new 'clean: no names provided' if names.empty?
+      @names = names
+    end
+
+    attr_reader :names, :show_names
+
+    def execute(ctx)
+      @names.each do |name|
+        ename = ctx.expand_name(name)
+
+        if ctx.raw?
+          val = ctx.raw_get(ename)
+          ctx.unset(ename) if val && val.empty?
+        else
+          val = ctx.smart_get(ename)
+          if val.type != :empty
+            val.clean!
+            ctx.smart_set(ename, val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/envo/cmd_copy.rb

@@ -0,0 +1,56 @@
+module Envo
+  class CmdCopy
+    Name = 'copy'
+    def self.register_help(help)
+      help.add_cmd 'copy <source-name> <target-name>', <<~EOF
+        copy value of source to target
+          shorthand: 'cp'
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+      parser.add_cmd('cp', ->(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(tokens, opts)
+      raise Envo::Error.new "copy: provide two names to copy. Use 'copy <source-name> <target-name>'" if tokens.size != 2
+      ParsedCmd.new(CmdCopy.new(tokens[0], tokens[1]), opts)
+    end
+
+    def initialize(source, target)
+      @source = source
+      @target = target
+    end
+
+    attr_accessor :source, :target
+
+    def execute(ctx)
+      esrc = ctx.expand_name(@source)
+      raw_src = ctx.raw_get(esrc)
+      raise Envo::Error.new "copy: no such var '#{esrc}'" if !raw_src && !ctx.force?
+      return if !raw_src
+
+      etarget = ctx.expand_name(@target)
+      raw_target = ctx.raw_get(etarget)
+
+      ok = !raw_target
+      ok ||= ctx.ask("'#{etarget}' already exists. Overwrite?")
+      raise Envo::Error.new "'#{etarget}' exists" if !ok
+
+      return if esrc == etarget # copy something over itself...
+      return if !raw_src && !raw_target # no point in doing anything if they don't exist
+
+      ctx.raw_set(etarget, raw_src)
+    end
+  end
+end

data/lib/envo/cmd_list.rb

@@ -0,0 +1,50 @@
+module Envo
+  class CmdList
+    Name = 'list'
+    def self.register_help(help)
+      help.add_cmd "list <name>", "show value of list environment variable which is a list"
+      help.add_cmd "list <name> add <val>", <<~EOF
+        add value to list if it's not already inside
+          --front - adds value to front of list (moves it to front if it's already inside)
+          --back  - adds value to back of list (moves it to back if it's already inside)
+      EOF
+      help.add_cmd "list <name> del <val|index>", <<~EOF
+        remove a value from a list
+        if the provided value is an integer, it's interpreted as an index in the list
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.parse_cli(args)
+      opts = CliParser.filter_opts_front(args)
+      raise Envo::Error.new "list: missing name. Use 'list <name> <cmd> <args>'" if args.empty?
+      name = args.shift
+      return ParsedCmd.new(CmdShow.new([name], true), opts) if args.empty? # just list <name>
+
+      cmd = args.shift
+      return CmdListAdd.parse_cli_args(name, args, opts) if cmd == 'add'
+      return CmdListDel.parse_cli_args(name, args, opts) if cmd == 'del'
+
+      raise Envo::Error.new "list: unkonwn subcommand #{cmd}"
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_script(tokens, opts) })
+    end
+
+    def self.parse_script(tokens, opts)
+      raise Envo::Error.new "list: missing name. Use 'list <name> <cmd> <args>'" if tokens.empty?
+      name = tokens.shift
+      return ParsedCmd.new(CmdShow.new([name], true), opts) if tokens.empty? # just list <name>
+
+      cmd = tokens.shift
+      return CmdListAdd.parse_script(name, tokens, opts) if cmd == 'add'
+      return CmdListDel.parse_tokens(name, tokens, opts) if cmd == 'del'
+
+      raise Envo::Error.new "list: unkonwn subcommand #{cmd}"
+    end
+  end
+end

data/lib/envo/cmd_list_add.rb

@@ -0,0 +1,102 @@
+module Envo
+  class CmdListAdd
+    def self.register_help(help)
+      help.add_cmd 'la <name> <val>', "shorthand for 'list <name> add <val>'"
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd('la', ->(cmd, args) { parse_cli_all(args) })
+    end
+
+    def self.register_script_parser(parser)
+    end
+
+    def self.parse_cli_all(args)
+      opts = CliParser.filter_opts_front(args)
+      raise Envo::Error.new "list-add: missing name. Use 'la <name> <val>'" if args.empty?
+      parse_cli_args(args[0], args[1..], opts)
+    end
+
+    def self.parse_script(name, tokens, opts)
+      pos = nil
+      opts.filter! do |opt|
+        case opt
+        when 'front', 'top'
+          pos = :front
+          false
+        when 'back', 'bottom'
+          pos = :back
+          false
+        else
+          true
+        end
+      end
+
+      ParsedCmd.new(CmdListAdd.new(name, tokens, pos), opts)
+    end
+
+    def self.parse_cli_args(name, args, opts)
+      opts += CliParser.filter_opts(args)
+      pos = nil
+      opts.filter! do |opt|
+        case opt
+        when '--front', '--top'
+          pos = :front
+          false
+        when '--back', '--bottom'
+          pos = :back
+          false
+        else
+          true
+        end
+      end
+
+      ParsedCmd.new(CmdListAdd.new(name, args, pos), opts)
+    end
+
+    def initialize(name, values, pos)
+      raise Envo::Error.new 'list-add: no values to add provided' if values.empty?
+      @name = name
+      @values = values
+      @pos = pos
+    end
+
+    attr_accessor :name, :values, :pos
+
+    def execute(ctx)
+      ename = ctx.expand_name(@name)
+
+      list = ctx.smart_get(ename)
+
+      ok = list.list?
+      if !ok
+        if list.type == :empty
+          ok ||= ctx.ask("#{ename} doesn't exist. Create?")
+        else
+          ok ||= ctx.ask("#{ename} is not a list, but a #{list.type}. Convert?")
+        end
+      end
+      raise Envo::Error.new "list-add: adding list item to a non-list" if !ok
+
+      list = list.to_list
+
+      ordered = @pos == :front ? values.reverse : values
+      ordered.each do |val|
+        val = ctx.expand_value(val)
+
+        ok = list.accept_item?(val)
+        ok ||= ctx.ask("Add #{val.type} to #{list.type}?")
+        raise Envo::Error.new "list-add: adding #{val.type} to #{list.type}" if !ok
+
+        idesc = val.invalid_description
+        ok = !idesc
+        ok ||= ctx.ask("Add #{idesc} to #{ename}?")
+        raise Envo::Error.new "list-add: adding #{idesc} to #{ename}" if !ok
+
+        list.insert(val.to_s, @pos)
+      end
+
+      ctx.smart_set(ename, list)
+    end
+  end
+end

data/lib/envo/cmd_list_del.rb

@@ -0,0 +1,78 @@
+module Envo
+  class CmdListDel
+    def self.register_help(help)
+      help.add_cmd 'ld <name> <val|index>', "shorthand for 'list <name> del <val|index>'"
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd('ld', ->(cmd, args) { parse_cli_all(args) })
+    end
+
+    def self.register_script_parser(parser)
+    end
+
+    def self.parse_cli_all(args)
+      opts = CliParser.filter_opts_front(args)
+      raise Envo::Error.new "list-del: missing name. Use 'ld <name> <val|index>'" if args.empty?
+      parse_cli_args(args[0], args[1..], opts)
+    end
+
+    def self.parse_cli_args(name, args, opts)
+      opts += CliParser.filter_opts(args)
+      parse_tokens(name, args, opts)
+    end
+
+    def self.parse_tokens(name, tokens, opts)
+      raise Envo::Error.new "list-del: provide one value or index to delete. Use 'list <name> del <val|index>'" if tokens.size != 1
+      ParsedCmd.new(CmdListDel.new(name, tokens[0]), opts)
+    end
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    attr_accessor :name, :value
+
+    def execute(ctx)
+      ename = ctx.expand_name(@name)
+
+      list = ctx.smart_get(ename)
+
+      if list.type == :empty
+        return if ctx.force?
+        raise Envo::Error.new "list-del: deleting an item from a non-exiting value"
+      end
+
+      ok = list.list?
+      ok ||= ctx.ask("#{ename} is not a list, but a #{list.type}. Convert?")
+      raise Envo::Error.new "list-del: deleting an item from a non-list" if !ok
+
+      list = list.to_list
+
+      val = ctx.expand_value(@value)
+      if val.list?
+        raise Envo::Error.new "list-del: can't delete a list from a list" if !ctx.force?
+        return
+      end
+      val = val.to_s
+
+      index = val.to_i
+      if !ctx.raw? && index.to_s == val
+        deleted = list.delete_at(index)
+        if !deleted
+          raise Envo::Error.new "list-del: no index #{val} in #{ename}" if !ctx.force?
+          return
+        end
+      else
+        deleted = list.delete(val)
+        if !deleted
+          raise Envo::Error.new "list-del: no item '#{val}' in #{ename}" if !deleted
+          return
+        end
+      end
+
+      ctx.smart_set(ename, list)
+    end
+  end
+end

data/lib/envo/cmd_path.rb

@@ -0,0 +1,28 @@
+module Envo
+  class CmdPath
+    Name = 'path'
+    def self.register_help(help)
+      help.add_cmd "path <args>", <<~EOF
+        shorthand for 'list @path <args>'
+          shorthand: 'p'
+      EOF
+    end
+
+    def self.register_cli_parser(parser)
+      parser.add_cmd(Name, ->(cmd, args) { parse_cli(args) })
+      parser.add_cmd('p', ->(cmd, args) { parse_cli(args) })
+    end
+
+    def self.register_script_parser(parser)
+      parser.add_cmd(Name, ->(cmd, tokens, opts) { parse_script(tokens, opts) })
+    end
+
+    def self.parse_cli(args)
+      CmdList.parse_cli(args.unshift('@path'))
+    end
+
+    def self.parse_script(tokens, opts)
+      CmdList.parse_script(tokens.unshift('@path'), opts)
+    end
+  end
+end

data/lib/envo/cmd_reset.rb

@@ -0,0 +1,66 @@
+module Envo
+  class CmdReset
+    Name = 'reset'
+    def self.register_help(help)
+      help.add_cmd 'reset <name>[=[<val>]]', <<~EOF
+        set or unset value of an existing environment variable
+        produce an error if the variable doesn't exist
+      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)
+      raise Envo::Error.new "reset: missing name. Use 'reset <name> [= [<val>]]'" if args.empty? || args[0][0] == '='
+      if args.size == 1
+        arg = args[0]
+        cnt = arg.count('=')
+        return ParsedCmd.new(CmdReset.new(arg, nil), opts) if cnt == 0
+        if cnt == 1 && arg[-1] == '='
+          split = arg.split('=')
+          return ParsedCmd.new(CmdReset.new(split[0], nil), opts) if split.size == 1
+        end
+      elsif args.size == 2
+        return ParsedCmd.new(CmdReset.new(args[0], nil), opts) if args[1] == '='
+      end
+
+      helper = CmdSet.parse_cli(args).cmd
+      ParsedCmd.new(CmdReset.new(helper.name, helper), opts)
+    end
+
+    def self.parse_script(args)
+      puts "#{Name} parse_script"
+    end
+
+    def initialize(name, helper)
+      @name = name
+      @helper = helper
+    end
+
+    attr_accessor :name, :helper
+
+    def execute(ctx)
+      ename = ctx.expand_name(@name)
+
+      raise Envo::Error.new "reset: no such var '#{ename}'" if !ctx.raw_get(ename)
+
+      if !@helper
+        ctx.unset(ename)
+      else
+        @helper.name = @name
+        @helper.execute(ctx)
+      end
+    end
+  end
+end