class Cmds

# File lib/cmds/sugar.rb, line 92
def self.assert template, *args, **kwds, &io_block
  Cmds.new(template).capture(*args, **kwds, &io_block).assert
end

# File lib/cmds/sugar.rb, line 65
def self.capture template, *args, **kwds, &input_block
  Cmds.new(template).capture *args, **kwds, &input_block
end

# File lib/cmds/util.rb, line 128
  def self.check_status cmd, status, err = nil
    unless status.equal? 0
      msg = NRSER.squish <<-END
        command `#{ cmd }` exited with status #{ status }
      END
      
      if err
        msg += " and stderr:\n\n" + err
      end
      
      # Remove NULL bytes (not sure how they get in there...)
      msg = msg.delete("\000")
      
      raise SystemCallError.new msg, status
    end
  end

# File lib/cmds/sugar.rb, line 159
def self.chomp template, *args, **kwds, &input_block
  out(template, *args, **kwds, &input_block).chomp
end

# File lib/cmds/sugar.rb, line 180
def self.chomp! template, *args, **kwds, &input_block
  out!(template, *args, **kwds, &input_block).chomp
end

# File lib/cmds/debug.rb, line 96
def self.debug msg, values = {}
  # don't even bother unless debug logging is turned on
  return unless Debug.on?
  Debug.logger.debug Debug.format(msg, values)
end

# File lib/cmds/util/defaults.rb, line 106
def self.defaults opts, keys = '*', extras = {}
  if keys == '*'
    DEFAULTS.deep_dup
  else
    keys.
      map {|key|
        [key, DEFAULTS.fetch(key)]
      }.
      to_h
  end.
    merge!( extras ).
    merge!( opts )
end

# File lib/cmds/sugar.rb, line 198
def self.err template, *args, **kwds, &input_block
  capture(template, *args, **kwds, &input_block).err
end

# File lib/cmds/sugar.rb, line 86
def self.error? template, *args, **kwds, &io_block
  Cmds.new(template).error? *args, **kwds, &io_block
end

# File lib/cmds/util/shell_escape.rb, line 38
def self.esc str
  Shellwords.escape str
end

# File lib/cmds/util.rb, line 46
def self.format string, with = :squish
  case with
  when nil
    string
    
  when :squish
    NRSER.squish string
    
  when :pretty
    pretty_format string
  
  else
    with.call string
  end
end

# File lib/cmds.rb, line 237
def initialize  template, **options
  options = defaults options
  
  if options.key? :opts
    options[:kwds][:opts] = options.delete :opts
  end
  
  logger.trace "Cmd constructing...",
    template: template,
    options: options

  @template = template
  
  # Assign options to instance variables
  options.each { |key, value|
    instance_variable_set "@#{ key }", value
  }
  
  # An internal cache of the last result of calling {#prepare}, or `nil` if
  # {#prepare} has never been called. Kinda funky but ends up being useful.
  @last_prepared_cmd = nil
end

# File lib/cmds/sugar.rb, line 81
def self.ok? template, *args, **kwds, &io_block
  Cmds.new(template).ok? *args, **kwds, &io_block
end

# File lib/cmds/sugar.rb, line 120
def self.out template, *args, **kwds, &input_block
  Cmds.new(template).out *args, **kwds, &input_block
end

# File lib/cmds/sugar.rb, line 141
def self.out! template, *args, **kwds, &input_block
  Cmds.new(template).out! *args, **kwds, &input_block
end

# File lib/cmds/sugar.rb, line 40
def self.prepare template, *args, **kwds, &options_block
  options = if options_block
    options_block.call
  else
    {}
  end
  
  Cmds.new(template, **options).prepare *args, **kwds
end

# File lib/cmds/util.rb, line 63
def self.pretty_format string
  string = string.gsub(/\n(\s*\n)+\n/, "\n\n")
  
  string.lines.map {|line|
    line = line.rstrip
    
    if line.end_with? '\\'
      line
    elsif line == ''
      '\\'
    elsif line =~ /\s$/
      line + '\\'
    else
      line + ' \\'
    end
  }.join("\n")
end

# File lib/cmds/util/shell_escape.rb, line 72
def self.quote_dance string, quote_type
  outside = QUOTE_TYPES.fetch quote_type
  inside = QUOTE_VALUES[QUOTE_VALUES[0] == outside ? 1 : 0]
  
  outside +
  string.gsub(
    outside,
    outside + inside + outside + inside + outside
  ) +
  outside
end

# File lib/cmds/util.rb, line 81
def self.replace_shortcuts template
  template
    .gsub(
      # %s => <%= arg %>
      /(?<=\A|\=|[[:space:]])\%s(?=\Z|[[:space:]])/,
      '<%= arg %>'
    )
    .gsub(
      # %%s => %s (escaping)
      /(?<=\A|[[:space:]])(\%+)\%s(?=\Z|[[:space:]])/,
      '\1s'
    )
    .gsub(
      # %{key} => <%= key %>, %{key?} => <%= key? %>
      /(?<=\A|\=|[[:space:]])\%\{([a-zA-Z_]+\??)\}(?=\Z|[[:space:]])/,
      '<%= \1 %>'
    )
    .gsub(
      # %%{key} => %{key}, %%{key?} => %{key?} (escaping)
      /(?<=\A|[[:space:]])(\%+)\%\{([a-zA-Z_]+\??)\}(?=\Z|[[:space:]])/,
      '\1{\2}\3'
    )
    .gsub(
      # %<key>s => <%= key %>, %<key?>s => <%= key? %>
      /(?<=\A|\=|[[:space:]])\%\<([a-zA-Z_]+\??)\>s(?=\Z|[[:space:]])/,
      '<%= \1 %>'
    )
    .gsub(
      # %%<key>s => %<key>s, %%<key?>s => %<key?>s (escaping)
      /(?<=\A|[[:space:]])(\%+)\%\<([a-zA-Z_]+\??)\>s(?=\Z|[[:space:]])/,
      '\1<\2>s'
    )
end

# File lib/cmds/util/shell_escape.rb, line 93
def self.single_quote string
  quote_dance string, :single
end

# File lib/cmds/spawn.rb, line 116
  def self.spawn  cmd,
                  env: {},
                  input: nil,
                  **spawn_opts,
                  &io_block
    logger.trace "entering Cmds#spawn",
      cmd: cmd,
      env: env,
      input: input,
      spawn_opts: spawn_opts,
      io_block: io_block
    
    # Process.spawn doesn't like a `nil` chdir
    if spawn_opts.key?( :chdir ) && spawn_opts[:chdir].nil?
      spawn_opts.delete :chdir
    end
    
    # create the handler that will be yielded to the input block
    handler = Cmds::IOHandler.new

    # handle input
    #
    # if a block was provided it overrides the `input` argument.
    #
    if io_block
      case io_block.arity
      when 0
        # when the input block takes no arguments it returns the input
        
        # Check that `:input` kwd wasn't provided.
        unless input.nil?
          raise ArgumentError,
            "Don't call Cmds.spawn with `:input` keyword arg and a block"
        end
        
        input = io_block.call
        
      when 1
        # when the input block takes one argument, give it the handler and
        # ignore the return value
        io_block.call handler

        # if input was assigned to the handler in the block, use it as input
        unless handler.in.nil?
          
          # Check that `:input` kwd wasn't provided.
          unless input.nil?
            raise ArgumentError,
              "Don't call Cmds.spawn with `:input` keyword arg and a block"
          end
          
          input = handler.in
        end
        
      else
        # bad block provided
        raise ArgumentError.new NRSER.squish <<-BLOCK
          provided input block must have arity 0 or 1
        BLOCK
      end # case io_block.arity
    end # if io_block

    logger.trace "looking at input...",
      input: input

    # (possibly) create the input pipe... this will be nil if the provided
    # input is io-like. in this case it will be used directly in the
    # `spawn` options.
    in_pipe = case input
    when nil, String
      logger.trace "input is a String or nil, creating pipe..."

      in_pipe = Cmds::Pipe.new "INPUT", :in
      spawn_opts[:in] = in_pipe.r

      # don't buffer input
      in_pipe.w.sync = true
      in_pipe

    else
      logger.trace "input should be io-like, setting spawn opt.",
        input: input
      if input == $stdin
        logger.trace "input is $stdin."
      end
      spawn_opts[:in] = input
      nil

    end # case input

    # (possibly) create the output pipes.
    #
    # `stream` can be told to send it's output to either:
    #
    # 1.  a Proc that will invoked with each line.
    # 2.  an io-like object that can be provided as `spawn`'s `:out` or
    #     `:err` options.
    #
    # in case (1) a `Cmds::Pipe` wrapping read and write piped `IO` instances
    # will be created and assigned to the relevant of `out_pipe` or `err_pipe`.
    #
    # in case (2) the io-like object will be sent directly to `spawn` and
    # the relevant `out_pipe` or `err_pipe` will be `nil`.
    #
    out_pipe, err_pipe = [
      ["ERROR", :err],
      ["OUTPUT", :out],
    ].map do |name, sym|
      logger.trace "looking at #{ name }..."
      
      dest = handler.public_send sym
      
      # see if hanlder.out or hanlder.err is a Proc
      if dest.is_a? Proc
        logger.trace "#{ name } is a Proc, creating pipe..."
        pipe = Cmds::Pipe.new name, sym
        # the corresponding :out or :err option for spawn needs to be
        # the pipe's write handle
        spawn_opts[sym] = pipe.w
        # return the pipe
        pipe

      else
        logger.trace "#{ name } should be io-like, setting spawn opt.",
          output: dest
        spawn_opts[sym] = dest
        # the pipe is nil!
        nil
      end
    end # map outputs

    logger.trace "spawning...",
      env: env,
      cmd: cmd,
      opts: spawn_opts

    pid = Process.spawn env.map {|k, v| [k.to_s, v]}.to_h,
                        cmd,
                        spawn_opts

    logger.trace "spawned.",
      pid: pid

    wait_thread = Process.detach pid
    wait_thread[:name] = "WAIT"

    logger.trace "wait thread created.",
      thread: wait_thread

    # close child ios if created
    # the spawned process will read from in_pipe.r so we don't need it
    in_pipe.r.close if in_pipe
    # and we don't need to write to the output pipes, that will also happen
    # in the spawned process
    [out_pipe, err_pipe].each {|pipe| pipe.w.close if pipe}

    # create threads to handle any pipes that were created

    in_thread = if in_pipe
      Thread.new do
        Thread.current[:name] = in_pipe.name
        logger.trace "thread started, writing input..."

        in_pipe.w.write input unless input.nil?

        logger.trace "write done, closing in_pipe.w..."
        in_pipe.w.close

        logger.trace "thread done."
      end # Thread
    end

    out_thread, err_thread = [out_pipe, err_pipe].map do |pipe|
      if pipe
        Thread.new do
          Thread.current[:name] = pipe.name
          logger.trace "thread started"

          loop do
            logger.trace "blocking on gets..."
            line = pipe.r.gets
            if line.nil?
              logger.trace "received nil, output done."
            else
              logger.trace \
                "received #{ line.bytesize } bytes, passing to handler."
            end
            handler.thread_send_line pipe.sym, line
            break if line.nil?
          end

          logger.trace \
            "reading done, closing pipe.r (unless already closed)..."
          pipe.r.close unless pipe.r.closed?

          logger.trace "thread done."
        end # thread
      end # if pipe
    end # map threads

    logger.trace "handing off main thread control to the handler..."
    begin
      handler.start

      logger.trace "handler done."

    ensure
      # wait for the threads to complete
      logger.trace "joining threads..."

      [in_thread, out_thread, err_thread, wait_thread].each do |thread|
        if thread
          logger.trace "joining #{ thread[:name] } thread..."
          thread.join
        end
      end

      logger.trace "all threads done."
    end

    status = wait_thread.value.exitstatus
    logger.trace "exit status: #{ status.inspect }"

    logger.trace "checking @assert and exit status..."
    if @assert && status != 0
      # we don't necessarily have the err output, so we can't include it
      # in the error message
      msg = NRSER.squish <<-BLOCK
        streamed command `#{ cmd }` exited with status #{ status }
      BLOCK

      raise SystemCallError.new msg, status
    end

    logger.trace "streaming completed."

    return status
  end

# File lib/cmds/sugar.rb, line 97
def self.stream template, *subs, &input_block
  Cmds.new(template).stream *subs, &input_block
end

# File lib/cmds/sugar.rb, line 102
def self.stream! template, *args, **kwds, &io_block
  Cmds.new(template).stream! *args, **kwds, &io_block
end

# File lib/cmds/util.rb, line 26
def self.tokenize *values, **opts
  values.map {|value|
    case value
    when Hash
      tokenize_options value, **opts
    else
      tokenize_value value, **opts
    end
  }.flatten.join ' '
end

# File lib/cmds/util/tokenize_option.rb, line 43
  def self.tokenize_option name, value, **opts
    # Set defaults for any options not passed
    opts = defaults opts, TOKENIZE_OPT_KEYS
    
    # Validate `name`
    unless name.is_a?(String) && name.length > 0
      raise ArgumentError.new NRSER.squish <<-END
        `name` must be a String of length greater than zero,
        found #{ name.inspect }
      END
    end
    
    name = name.gsub( '_', '-' ) if opts[:dash_opt_names]
    
    # Set type (`:short` or `:long`) prefix and name/value separator depending
    # on if name is "short" (single character) or "long" (anything else)
    #
    type, prefix, separator = if name.length == 1
      # -b <value> style (short)
      [ :short, '-', opts[:short_opt_separator] ]
    else
      # --blah=<value> style (long)
      [ :long, '--', opts[:long_opt_separator] ]
    end
    
    case value
    
    # Special cases (booleans), where we may want to emit an option name but
    # no value (depending on options)
    #
    when true
      # `-b` or `--blah` style token
      [prefix + esc(name)]
      
    when false
      case opts[:false_mode]
      when :omit, :ignore
        # Don't emit any token for a false boolean
        []
      
      when :negate, :no
        # Emit `--no-blah` style token
        #
        if type == :long
          # Easy one
          ["--no-#{ esc(name) }"]
        
        else
          # Short option... there seems to be little general consensus on how
          # to handle these guys; I feel like the most common is to invert the
          # case, which only makes sense for languages that have lower and
          # upper case :/
          case opts[:false_short_opt_mode]
          
          when :capitalize, :cap, :upper, :upcase
            # Capitalize the name
            #
            # {x: false} => ["-X"]
            #
            # This only really makes sense for lower case a-z, so raise if it's
            # not in there
            unless "a" <= name <= "z"
              raise ArgumentError.new binding.erb <<-END
                Can't negate CLI option `<%= name %>` by capitalizing name.
                
                Trying to tokenize option `<%= name %>` with `false` value and:
                
                1.  `:false_mode` is set to `<%= opts[:false_mode] %>`, which
                    tells {Cmds.tokenize_option} to emit a "negating" name with
                    no value like
                    
                        {update: false} => --no-update
                    
                2.  `:false_short_opt_mode` is set to `<%= opts[:false_short_opt_mode] %>`,
                    which means negate through capitalizing the name character,
                    like:
                    
                        {u: false} => -U
                
                3.  But this is only implemented for names in `a-z`
                
                Either change the {Cmds} instance configuration or provide a
                different CLI option name or value.
              END
            end
            
            # Emit {x: false} => ['-X'] style
            ["-#{ name.upcase }"]
          
          when :long
            # Treat it the same as a long option,
            # emit {x: false} => ['--no-x'] style
            #
            # Yeah, I've never seen it anywhere else, but it seems reasonable I
            # guess..?
            #
            ["--no-#{ esc(name) }"]
          
          when :string
            # Use the string 'false' as a value
            [prefix + esc( name ) + separator + 'false']
          
          when String
            # It's some custom string to use
            [prefix + esc( name ) + separator + esc( string )]
            
          else
            raise ArgumentError.new binding.erb <<-END
              Bad `:false_short_opt_mode` value:
              
                  <%= opts[:false_short_opt_mode].pretty_inspect %>
              
              Should be
              
              1.  :capitalize (or :cap, :upper, :upcase)
              2.  :long
              3.  :string
              4.  any String
              
            END
            
          end # case opts[:false_short_opt_mode]
        end # if :long else
      else
        raise ArgumentError.new NRSER.squish <<-END
          bad :false_mode option: #{ opts[:false_mode] },
          should be :omit or :no
        END
      end
    
    # General case
    else
      # Tokenize the value, which may
      #
      # 1.  Result in more than one token, like when `:array_mode` is `:repeat`
      #     (in which case we want to emit multiple option tokens)
      #
      # 2.  Result in zero tokens, like when `value` is `nil`
      #     (in which case we want to emit no option tokens)
      #
      # and map the resulting tokens into option tokens
      #
      tokenize_value( value, **opts ).map { |token|
        prefix + esc(name) + separator + token
      }
    
    end # case value
  end

# File lib/cmds/util/tokenize_options.rb, line 32
def self.tokenize_options hash, **opts
  opts = defaults opts, TOKENIZE_OPT_KEYS
  
  hash.map {|key, value|
    # keys need to be strings
    key = key.to_s unless key.is_a? String

    [key, value]

  }.sort {|(key_a, value_a), (key_b, value_b)|
    # sort by the (now string) keys
    key_a <=> key_b

  }.map {|key, value|
    tokenize_option key, value, **opts
    
  }.flatten.join ' '
end

# File lib/cmds/util/tokenize_value.rb, line 60
  def self.tokenize_value value, **opts
    opts = defaults opts, TOKENIZE_OPT_KEYS
      
    case value
    when nil
      # `nil` values produces no tokens
      []
      
    when Array
      # The PITA one...
      #
      # May produce one or multiple tokens.
      #
      
      # Flatten the array value if option is set
      value = value.flatten if opts[:flatten_array_values]
      
      case opts[:array_mode]
      when :repeat
        # Encode each entry as it's own token
        #
        # [1, 2, 3] => ["1", "2", "3"]
        #
        
        # Pass entries back through for individual tokenization and flatten
        # so we are sure to return a single-depth array
        value.map { |entry| tokenize_value entry, **opts }.flatten
        
      when :join
        # Encode all entries as one joined string token
        #
        # [1, 2, 3] => ["1,2,3"]
        #
        
        [esc( value.join opts[:array_join_string] )]
        
      when :json
        # Encode JSON dump as single token, single-quoted
        #
        # [1, 2, 3] => ["'[1,2,3]'"]
        
        [single_quote( JSON.dump value )]
        
      else
        # SOL
        raise ArgumentError.new binding.erb <<-END
          Bad `:array_mode` option:
          
              <%= opts[:array_mode].pretty_inspect %>
          
          Should be :join, :repeat or :json
          
        END
        
      end # case opts[:array_mode]
    
    when Hash
      # Much the same as array
      #
      # May produce one or multiple tokens.
      #
      
      case opts[:hash_mode]
      when :join
        # Join the key and value using the option and pass the resulting array
        # back through to be handled as configured
        tokenize_value \
          value.map { |k, v| [k, v].join opts[:hash_join_string] },
          **opts
      
      when :json
        # Encode JSON dump as single token, single-quoted
        #
        # [1, 2, 3] => [%{'{"a":1,"b":2,"c":3}'}]
        
        [single_quote( JSON.dump value )]
        
      else
        # SOL
        raise ArgumentError.new binding.erb <<-END
          Bad `:hash_mode` option:
          
              <%= opts[:hash_mode].pretty_inspect %>
          
          Should be :join, or :json
          
        END
      end
    
    else
      # We let {Cmds.esc} handle it, and return that as a single token
      [esc(value)]
      
    end
  end

# File lib/cmds/capture.rb, line 21
def capture *args, **kwds, &input_block
  logger.trace "entering Cmds#capture",
    args: args,
    kwds: kwds,
    input: input
  
  # extract input from block via `call` if one is provided,
  # otherwise default to instance variable (which may be `nil`)
  input = input_block.nil? ? input : input_block.call
  
  logger.trace "configured input",
    input: input
  
  # strings output will be concatenated onto
  out = ''
  err = ''

  logger.trace "calling Cmds.spawn..."
  
  status = spawn(*args, **kwds) do |io|
    # send the input to stream, which sends it to spawn
    io.in = input

    # and concat the output lines as they come in
    io.on_out do |line|
      out += line
    end

    io.on_err do |line|
      err += line
    end
  end
  
  logger.trace "Cmds.spawn completed",
    status: status

  # build a Result
  # result = Cmds::Result.new cmd, status, out_reader.value, err_reader.value
  result = Cmds::Result.new last_prepared_cmd, status, out, err

  # tell the Result to assert if the Cmds has been told to, which will
  # raise a SystemCallError with the exit status if it was non-zero
  result.assert if assert

  return result
end

# File lib/cmds.rb, line 427
def chomp *args, **kwds, &input_block
  out(*args, **kwds, &input_block).chomp
end

# File lib/cmds.rb, line 448
def chomp! *args, **kwds, &input
  out!(*args, **kwds, &input).chomp
end

# File lib/cmds.rb, line 269
def curry *args, **kwds, &input_block
  self.class.new template, {
    args: (self.args + args),
    kwds: (self.kwds.merge kwds),
    input: (input_block ? input_block.call : self.input),
    assert: self.assert,
    env: self.env,
    format: self.format,
    chdir: self.chdir,
  }
end

# File lib/cmds/util/defaults.rb, line 123
def defaults opts, keys = '*', extras = {}
  self.class.defaults opts, keys, extras
end

# File lib/cmds.rb, line 466
def err *args, **kwds, &input_block
  capture(*args, **kwds, &input_block).err
end

# File lib/cmds.rb, line 367
def error? *args, **kwds, &io_block
  stream(*args, **kwds, &io_block) != 0
end

# File lib/cmds.rb, line 353
def ok? *args, **kwds, &io_block
  stream(*args, **kwds, &io_block) == 0
end

# File lib/cmds.rb, line 392
def out *args, **kwds, &input_block
  capture(*args, **kwds, &input_block).out
end

# File lib/cmds.rb, line 410
def out! *args, **kwds, &input
  capture(*args, **kwds, &input).assert.out
end

# File lib/cmds.rb, line 333
def prepare *args, **kwds
  @last_prepared_cmd = Cmds.format render(*args, **kwds), self.format
end

# File lib/cmds.rb, line 372
def proxy
  stream do |io|
    io.in = $stdin
  end
end

# File lib/cmds.rb, line 295
def render *args, **kwds
  # Create the context for ERB
  context = Cmds::ERBContext.new(
    (self.args + args),
    
    self.kwds.merge( kwds ),
    
    tokenize_options_opts: TOKENIZE_OPT_KEYS.
      each_with_object( {} ) { |key, hash|
        value = instance_variable_get "@#{ key}"
        hash[key] = value unless value.nil?
      }
  )
  
  erb = Cmds::ShellEruby.new Cmds.replace_shortcuts( self.template )
  
  rendered = NRSER.dedent erb.result(context.get_binding)
  
  if self.env_mode == :inline && !self.env.empty?
    rendered = self.env.sort_by {|name, value|
      name
    }.map {|name, value|
      "#{ name }=#{ Cmds.esc value }"
    }.join("\n\n") + "\n\n" + rendered
  end
  
  rendered
end

# File lib/cmds/stream.rb, line 13
def stream *args, **kwds, &io_block
  logger.trace "entering Cmds#stream",
    args: args,
    kwds: kwds,
    io_block: io_block
  
  spawn *args, **kwds, &io_block
end

# File lib/cmds/stream.rb, line 32
def stream! *args, **kwds, &io_block
  status = stream *args, **kwds, &io_block
  
  Cmds.check_status last_prepared_cmd, status
  
  status
end

# File lib/cmds/spawn.rb, line 367
def spawn *args, **kwds, &io_block
  Cmds.spawn  prepare(*args, **kwds),
              input: input,
              # include env if mode is spawn argument
              env: (env_mode == :spawn_arg ? env : {}),
              chdir: chdir,
              unsetenv_others: !!@unsetenv_others,
              &io_block
end