Шифрование текста с ключом

require 'crypto'
 
RSpec.describe Crypto do
  subject { described_class.new key }
 
  describe 'decode and encode phrase' do
    let(:decoded) { 'Hello,_world!' }
    let(:encoded) { 'lHe,olo_wdlr!' }
    let(:key) { '312654' }
 
    describe '#encode' do
      it 'return encoded string' do
        expect(subject.encode decoded).to eq encoded
      end
    end
 
    describe '#decode' do
      it 'return decoded string' do
        expect(subject.decode encoded).to eq decoded
      end
    end
  end
 
  describe 'encode and decode string with random key' do
    it 'successfully' do
      decoded = 'Lorem ipsum dolor sit amet'
      (2..9).each do |i|
        crypto = Crypto.new (1..i).to_a.shuffle.join
        encoded = crypto.encode decoded
        expect(crypto.decode encoded).to eq decoded
      end
    end
  end
 
  describe 'key' do
    it 'must be sequental of unique numbers' do
      expect do
        described_class.new '11'
      end.to raise_error ArgumentError, 'Key values must be unique'
    end
 
    it 'length must be between 2 and 9' do
      expect do
        described_class.new '1234567890'
      end.to raise_error ArgumentError, 'Key length must be between 2 and 9'
    end
 
    it 'values must be in 123456789' do
      expect do
        described_class.new '0123'
      end.to raise_error ArgumentError, 'Key values must be in 123456789'
    end
  end
end

class Crypto
  def initialize(key)
    @key = validate key
  end
 
  def encode(str)
    perform str do |sequence|
      @key.map { |i| sequence[i - 1] }
    end
  end
 
  def decode(str)
    perform str do |sequence|
      normalize_encoded! sequence
 
      tmp = Array.new @key.size
      @key.each_with_index { |k, i| tmp[k - 1] = sequence[i] }
      tmp
    end
  end
 
  private
 
  # TODO: Extract to "Validator" module/class
  def validate(key)
    key = key.to_s
    key = key.chars.map(&:to_i)
 
    error = 'Key values must be of 123456789' if key.sort != (1..key.size).to_a
    error = 'Key values must be unique' if key.uniq.length != key.length
    error = 'Key length must be between 2 and 9' if key.size < 2 || key.size > 9
    raise ArgumentError, error if error
 
    return key
  end
 
  def perform(str)
    str.chars
      .each_slice(@key.size)
      .map { |sequence| yield sequence }
      .join
  end
 
  # Fill sequence with nil when key value is greater than sequence length
  def normalize_encoded!(sequence)
    return if @key.size == sequence.size
 
    encoded_size = sequence.size
    @key.each_with_index do |k, i|
      sequence.insert(i, nil) if k > encoded_size
    end
  end
end