Необходимо написать программу на Ruby, которая генерирует последовательность определённого вида

s = '1'
6.times do |i|
  puts s
 
  s = s.split('')
    .chunk_while { |a, b| a == b }
    .reduce('') { |s, el| "#{s}#{el.size}#{el.first}" }
end

# frozen_string_literal: true
 
ruby '2.6.3'
 
source "https://rubygems.org"
 
git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
group :development, :test do
  gem 'rspec', '~> 3.8.0'
end

require 'sequences'

describe Sequences::RepetitiveSequences do
  it { expect(described_class).to respond_to(:call) }
  it { should respond_to(:to_s) }
 
  it 'should return 11 for 1' do
    expect(described_class.call('1')).to eq('11')
  end
 
  it 'should return 21 for 11' do
    expect(described_class.call('11')).to eq('21')
  end
 
  it 'should return 1211 for 21' do
    expect(described_class.call('21')).to eq('1211')
  end
 
  it 'should return 111221 for 1211' do
    expect(described_class.call('1211')).to eq('111221')
  end
 
  it 'should return 312211 for 111221' do
    expect(described_class.call(111221)).to eq('312211')
  end
 
  it 'should return 3a2b1c4f for aaabbcffff' do
    expect(described_class.call('aaabbcffff')).to eq('3a2b1c4f')
  end
end

# frozen_string_literal: true
 
require_relative 'sequences/repetitive_sequences'
 
module Sequences
  VERSION = '0.0.1'
end

module Sequences
  class RepetitiveSequences
    attr_reader :sequence
 
    def self.call(str)
      new(str).to_s
    end
 
    def initialize(string = nil)
      @sequence = []
      perform string.to_s.split('')
    end
 
    def to_s
      @sequence.reduce('') { |s, el| "#{s}#{el.size}#{el.first}" }
    end
 
    private
 
    def last_element
      @sequence.last
    end
 
    def last_element?(value)
      !last_element.nil? && last_element.first == value
    end
 
    def add_element(value)
      if last_element? value
        last_element.push value
      else
        @sequence.push [value]
      end
    end
 
    def perform(elements)
      elements.each { |element| add_element element }
    end
  end
end

#!/usr/bin/env ruby
require 'optparse'
require_relative '../lib/sequences'
 
options = {
  source_string: 1,
  iterations: 5
}
 
parser = OptionParser.new do |opts|
  exec = File.basename($PROGRAM_NAME)
  opts.banner = "Usage: #{exec} [options]"
 
  opts.on('-s SRC', '--source SRC',
          'Source string to be proccessed, default: "1"') do |str|
    options[:source_string] = str
  end
 
  opts.on('-i COUNT', '--iterations COUNT', Integer,
          'Number of iterations to be proccessed, default: 5') do |i|
    options[:iterations] = i
  end
end
 
parser.parse!
s = options[:source_string]
 
options[:iterations].times do
  puts s
  s = Sequences::RepetitiveSequences.call(s)
end