How to split a string while conserving split elements as empty strings?

I'm trying to split a string so that elements that have been "split" are conserved as empty strings, for example with a string of "abaca" I need the result to be ["", "b", "", "c", ""] or a string of "xzxzxz" to result in ["x","","x","","x",""] Simply adding empty elements does not work, as I do not know whether the element I split with may exist at the start or end of the string.

I've tried to use interspersing, however every method I've found for that has led to either an error or not what I wanted. Apart from that, I have not found anything else that could help.

For this problem it's more convenient to match a regular expression than it is to split on one.

def doit(str, spl)
  sp = Regexp.escape(spl)
  str.gsub(/#{sp}|.+?(?=#{sp}|$)/).map { |s| s == spl ? " " : s }
end

doit('abaca', 'a')             #=> [" ", "b", " ", "c", " "]
doit('xzxzxz', 'z')            #=> ["x", " ", "x", " ", "x", " "]  
doit('nowiswasistoday', 'is')  #=> ["now", " ", "was", " ", "today"]
doit('iswasistoday', 'is')     #=> [" ", "was", " ", "today"] 
doit('i?si?s', '?')            #=> ["i", " ", "si", " ", "s"]

Here's an example of the steps.

str = 'iswasistoday'
spl = 'is'

<!-->
sp = Regexp.escape(spl)
#=> "is"

Here I am using Regexp.escape to escape characters of spl that have special meaning in regular expressions. We see that sp is the same as spl in this case, but in the last example above ? has a special meaning in regular expressions (namely, to make matches optional or to match as few characters as possible). In that case Regexp.escape('?') #=> "\\?". Continuing,

rgx = /#{sp}|.+?(?=#{sp}|$)/
  #=> /is|.+?(?=is|$)/

<!-->
enum = str.gsub(rgx)
#=> #<Enumerator: "iswasistoday":gsub(/is|.+?(?=is|$)/)>

Here I am using the form of String#gsub that takes a single argument and no block, returning an enumerator that generates matches of it's argument, here a regular expression. We can see the matches that will be generated by converting this enumerator to an array.

enum.to_a
  #=> ["is", "was", "is", "today"]

The last step follows.

enum.map { |s| s == spl ? " " : s }
  #=> [" ", "was", " ", "today"]

The regular expression has the following elements.

/
#{sp}     match the value of the variable sp
|         or
.+        match one or more characters other than line terminators
?         make previous match relunctant, matching as few characters as possible
(?=       begin a positive lookahead
  #{sp}   match the value of the variable sp
  |       or
  $       match the end of the string
)         end the positive lookahead
/

You could use each_char to iterate each character, then map them yourself.

'abaca'.each_char.map { |c| c.eql?('a') ? ' ' : c }
=> [" ", "b", " ", "c", " "]

'xzxzxz'.each_char.map { |c| c.eql?('z') ? ' ' : c }
=> ["x", " ", "x", " ", "x", " "]