chargen.rb

#!/usr/bin/env ruby
require 'optparse'
require 'set'

=begin
===============================================
  Random character generator script

  Command-line usage:
    ./chargen.rb [-w <length>] [-a] text

  REPL usage:
    process "text", alphabet: <is_alphabet_mode>

===============================================
=end

module CharacterGenerator
  @@Ranges = [
    (0x0021..0x007E), # Numbers
    (0x0100..0x024F), # Latin extended
    (0x0250..0x02AF), # IPA extensions
    (0x0370..0x052F), # Greek/Cyrillic
    (0x2200..0x22FF), # Math
    (0x4E00..0x9FFF), # CJK
  ]

  public

  def self.from_range(range_start, range_end)
    range_bounds = [range_start, range_end].sort
    range = (range_bounds[0]..range_bounds[1])
    try_conversion range
  end

  def self.ranges()
    @@Ranges
  end

  private

  def self.try_conversion(range)
    is_valid_unicode = lambda { |sym| not sym.match(/[[:print:]]/).nil? }

    conversion_successful = false

    range_array = range.to_a
    while range_array.length > 0 do
      ordinal = range_array.delete range_array.sample
      unichar = [ordinal].pack('U*')
      if is_valid_unicode.call unichar
        conversion_successful = true
        break
      end
    end

    if conversion_successful
      return unichar
    else
      raise EncodingError.new "No valid characters in range"
    end
  end
end

def get_random_char
  range = CharacterGenerator.ranges.sample
  CharacterGenerator.from_range(range.first, range.last)
end

def process(text, opt = {alphabet: false})
  out = ''
  if opt[:alphabet]
    charset = text.split('').to_set
    alphabet = {}
    charset.each do |c|
      # todo: random chars for alphabet may be duplicate
      alphabet[c] = if (c == ' ') then ' ' else get_random_char end
    end
    out = text.gsub /./, alphabet
  else
    out = text.split('').map{|c| if (c) == ' ' then c else get_random_char end}.join('')
  end

  puts out
  out
end

def abracadabra(char_count)
  out = ''
  if char_count > 0
    char_count.times do
      out += [*'a'..'z'].sample
    end
  end
  out
end

param = {
  is_alphabet: false,
  is_word: false,
  word_length: 0
}

opts = OptionParser.new do |opt|
  opt.on('-a', '--alphabet', 'Display string in random character alphabet mode') do |o|
    param[:is_alphabet] = true
  end
  opt.on('-w', '--word LENGTH', Integer, 'Output random word of specified length') do |o|
    param[:is_word] = true
    param[:word_length] = o
  end
  opt.on('-h', '--help', 'Show this message') do
    puts opts
    exit
  end
end
opts.parse!(ARGV)

if (param[:is_word] || !param[:is_alphabet]) && ARGV.length > 0
  puts 'Only non-random alphabet mode can have argument strings'
  exit
end

input = ''
if param[:is_word]
  input = abracadabra(param[:word_length])
elsif (ARGV.length == 0)
  words = []
  rand(1..5).times do
    words.push abracadabra(rand(3..20))
  end
  input = words.join(' ')
else
  input = ARGV.join(' ')
end

process(input, alphabet: param[:is_alphabet])

'10581099003210871080107610861088'.scan(/.{4}/).map(&:to_i).pack('U*')