class StringSplitter

# File lib/string_splitter.rb, line 59
def initialize(
  default_delimiter: DEFAULT_DELIMITER,
  include_captures: true,
  remove_empty: false, # TODO remove this
  remove_empty_fields: remove_empty,
  spread_captures: true
)
  @default_delimiter = default_delimiter
  @include_captures = include_captures
  @remove_empty_fields = remove_empty_fields
  @spread_captures = spread_captures
end

# File lib/string_splitter.rb, line 119
def rsplit(
  string,
  delimiter = @default_delimiter,
  at: nil, # alias for select
  except: nil, # alias for reject
  select: at,
  reject: except,
  &block
)
  result, splits, count, accept = init(
    string: string,
    delimiter: delimiter,
    select: select,
    reject: reject,
    block: block
  )

  return result unless splits

  result.unshift(splits.last.rhs)

  splits.reverse_each.with_index do |split, index|
    split.update!(count: count, index: index)

    if accept.call(split)
      # [lhs + captures] + result
      result.unshift(split.lhs, split.captures)
    else
      # prepend the lhs
      result[0] = split.lhs + split.separator + result[0]
    end
  end

  render(result)
end

# File lib/string_splitter.rb, line 82
def split(
  string,
  delimiter = @default_delimiter,
  at: nil, # alias for select
  except: nil, # alias for reject
  select: at,
  reject: except,
  &block
)
  result, splits, count, accept = init(
    string: string,
    delimiter: delimiter,
    select: select,
    reject: reject,
    block: block
  )

  return result unless splits

  result << splits.first.lhs

  splits.each_with_index do |split, index|
    split.update!(count: count, index: index)

    if accept.call(split)
      result << split.captures << split.rhs
    else
      # append the rhs
      result[-1] = result[-1] + split.separator + split.rhs
    end
  end

  render(result)
end

# File lib/string_splitter.rb, line 353
def compile(positions, action, count)
  # XXX note: we don't use modulo, because we don't want
  # out-of-bounds indices to silently work, e.g. we don't want:
  #
  #   ss.split("foo:bar:baz:quux", ":", at: -42)
  #
  # to mysteriously match when the index/position is 0/1
  #
  resolve = ->(int) { int.negative? ? count + 1 + int : int }

  # don't use Array(...) to wrap these as we don't want to convert ranges
  positions = positions.is_a?(Array) ? positions : [positions]

  positions = positions.map do |position|
    if position.is_a?(Integer)
      resolve[position]
    elsif position.is_a?(Range)
      rbegin = position.begin
      rend = position.end
      rexc = position.exclude_end?

      if rbegin.nil?
        Range.new(1, resolve[rend], rexc)
      elsif rend.nil?
        Range.new(resolve[rbegin], count, rexc)
      elsif rbegin.negative? || rend.negative? || (rend - rbegin).negative?
        from = resolve[rbegin]
        to = resolve[rend]
        to < from ? Range.new(to, from, rexc) : Range.new(from, to, rexc)
      else
        position
      end
    elsif position.is_a?(Set)
      position.map { |it| resolve[it] }.to_set
    else
      position
    end
  end

  ->(split) { case split.position when *positions then action else !action end }
end

# File lib/string_splitter.rb, line 174
def init(string:, delimiter:, select:, reject:, block:)
  return [[]] if string.empty?

  unless block
    if reject
      positions = reject
      action = Action::REJECT
    elsif select
      positions = select
      action = Action::SELECT
    else
      block = ACCEPT_ALL
    end
  end

  # use String#split if we can
  #
  # NOTE +reject!+ is no faster than +reject+ on MRI and significantly slower
  # on TruffleRuby

  if delimiter.is_a?(String)
    limit = -1

    if delimiter == ' '
      delimiter = / / # don't trim
    elsif delimiter.empty?
      limit = 0 # remove the trailing empty string
    end

    result = string.split(delimiter, limit)

    return [result] if result.length == 1 # delimiter not found: no splits

    if block == ACCEPT_ALL # return the (2 or more) fields
      result = result.reject(&:empty?) if @remove_empty_fields
      return [result]
    end

    splits = []

    result.each_cons(2) do |lhs, rhs| # 2 or more fields
      splits << Split.new(
        captures: [],
        lhs: lhs,
        rhs: rhs,
        separator: delimiter
      )
    end
  elsif delimiter == DEFAULT_DELIMITER && block == ACCEPT_ALL
    # non-empty separators so -1 is safe

    # XXX String#split with block was introduced in Ruby 2.6:
    #
    # - https://rubyreferences.github.io/rubychanges/2.6.html#stringsplit-with-block
    #
    # rather than sniffing, we'll just use the compatible version for now
    #
    # if @remove_empty_fields
    #     result = []
    #
    #     string.split(delimiter, -1) do |field|
    #         result << field unless field.empty?
    #     end
    # else
    #     result = string.split(delimiter, -1)
    # end

    result = string.split(delimiter, -1)
    result = result.reject(&:empty?) if @remove_empty_fields
    return [result]
  else
    splits = parse(string, delimiter)
  end

  count = splits.length

  return [[string]] if count.zero?

  block ||= compile(positions, action, count)
  [[], splits, count, block]
end

# File lib/string_splitter.rb, line 293
def parse(string, delimiter)
  # has_names = delimiter.is_a?(Regexp) && !delimiter.names.empty?
  splits = []
  start = 0

  # we don't use the argument passed to the +scan+ block here because it's a
  # string (the separator) if there are no captures, rather than an empty
  # array. we use match.captures instead to get the array
  string.scan(delimiter) do
    match = Regexp.last_match
    index, after = match.offset(0)
    separator = match[0]

    # ignore empty separators at the beginning and/or end of the string
    next if separator.empty? && (index.zero? || after == string.length)

    lhs = string.slice(start, index - start)
    splits.last.rhs = lhs unless splits.empty?

    # this is correct for the last/only match, but gets updated to the next
    # match's lhs for other matches
    rhs = match.post_match

    # captures = has_names ? Captures.new(match) : match.captures

    splits << Split.new(
      captures: match.captures,
      lhs: lhs,
      rhs: rhs,
      separator: separator
    )

    # advance the start index (the start of the next lhs) to the position
    # after the last character of the separator
    start = after
  end

  splits
end

# File lib/string_splitter.rb, line 256
def render(values)
  values.flat_map do |value|
    if value.is_a?(String)
      value.empty? && @remove_empty_fields ? REMOVE : [value]
    elsif @include_captures
      if @spread_captures
        # TODO make sure compact can return a Capture
        @spread_captures == :compact ? value.compact : value
      elsif value.empty?
        # we expose non-captures (string delimiters or regexps with no
        # captures) as empty arrays inside the block, so the type is
        # consistent, but it doesn't make sense to keep them in the
        # result
        REMOVE
      else
        [value]
      end
    else
      REMOVE
    end
  end
end