unique_names_generator 0.1.1

data/lib/unique_names_generator/dictionaries/numbers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module UniqueNamesGenerator
+  module Dictionaries
+    # Dictionary containing numbers
+    module Numbers
+      TERMS = (1..999).freeze
+
+      def self.list_all
+        TERMS.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/unique_names_generator/dictionaries/star_wars.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module UniqueNamesGenerator
+  module Dictionaries
+    # Dictionary containing star-wars characters
+    module StarWars
+      TERMS = [
+        'Ackbar',
+        'Adi Gallia',
+        'Anakin Skywalker',
+        'Arvel Crynyd',
+        'Ayla Secura',
+        'Bail Prestor Organa',
+        'Barriss Offee',
+        'Ben Quadinaros',
+        'Beru Whitesun lars',
+        'Bib Fortuna',
+        'Biggs Darklighter',
+        'Boba Fett',
+        'Bossk',
+        'C-3PO',
+        'Chewbacca',
+        'Cliegg Lars',
+        'Cordé',
+        'Darth Maul',
+        'Darth Vader',
+        'Dexter Jettster',
+        'Dooku',
+        'Dormé',
+        'Dud Bolt',
+        'Eeth Koth',
+        'Finis Valorum',
+        'Gasgano',
+        'Greedo',
+        'Gregar Typho',
+        'Grievous',
+        'Han Solo',
+        'IG-88',
+        'Jabba Desilijic Tiure',
+        'Jango Fett',
+        'Jar Jar Binks',
+        'Jek Tono Porkins',
+        'Jocasta Nu',
+        'Ki-Adi-Mundi',
+        'Kit Fisto',
+        'Lama Su',
+        'Lando Calrissian',
+        'Leia Organa',
+        'Lobot',
+        'Luke Skywalker',
+        'Luminara Unduli',
+        'Mace Windu',
+        'Mas Amedda',
+        'Mon Mothma',
+        'Nien Nunb',
+        'Nute Gunray',
+        'Obi-Wan Kenobi',
+        'Owen Lars',
+        'Padmé Amidala',
+        'Palpatine',
+        'Plo Koon',
+        'Poggle the Lesser',
+        'Quarsh Panaka',
+        'Qui-Gon Jinn',
+        'R2-D2',
+        'R4-P17',
+        'R5-D4',
+        'Ratts Tyerel',
+        'Raymus Antilles',
+        'Ric Olié',
+        'Roos Tarpals',
+        'Rugor Nass',
+        'Saesee Tiin',
+        'San Hill',
+        'Sebulba',
+        'Shaak Ti',
+        'Shmi Skywalker',
+        'Sly Moore',
+        'Tarfful',
+        'Taun We',
+        'Tion Medon',
+        'Wat Tambor',
+        'Watto',
+        'Wedge Antilles',
+        'Wicket Systri Warrick',
+        'Wilhuff Tarkin',
+        'Yarael Poof',
+        'Yoda',
+        'Zam Wesell'
+      ].freeze
+
+      def self.list_all
+        TERMS
+      end
+    end
+  end
+end

data/lib/unique_names_generator/seed.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module UniqueNamesGenerator
+  # Generate a reproducible seed from a given string
+  module Seed
+    class << self
+      def generate_seed(seed)
+        return nil if seed.nil?
+
+        transformed_string = transform_string(seed)
+        seed_decimal = mulberry32(transformed_string)
+        remove_decimal(seed_decimal)
+      end
+
+      private
+
+      def transform_string(seed)
+        return seed if seed.is_a?(Integer)
+
+        seed += "\x00"
+        ascii_values = seed.bytes
+
+        joined_values = ascii_values.join
+        joined_values.to_i
+      end
+
+      def remove_decimal(seed)
+        (seed * 10**16).to_i
+      end
+
+      def mulberry32(seed)
+        t = (seed + 0x6d2b79f5) & 0xffffffff
+
+        t = ((t ^ (t >> 15)) * (t | 1)) & 0xffffffff
+        t = (t ^ (t >> 7)) & 0xffffffff
+        t = (t ^ (t + ((t ^ (t >> 7)) * (t | 61) & 0xffffffff))) & 0xffffffff
+
+        ((t ^ (t >> 14)) & 0xffffffff) / 4294967296.0
+      end
+    end
+  end
+end

data/lib/unique_names_generator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module UniqueNamesGenerator
+  VERSION = '0.1.1'
+end

data/lib/unique_names_generator.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+# An implementation of a unique_names_generator in Ruby
+# with support for PRNG/seeds
+
+require_relative './unique_names_generator/seed'
+
+require_relative './unique_names_generator/dictionaries/adjectives'
+require_relative './unique_names_generator/dictionaries/animals'
+require_relative './unique_names_generator/dictionaries/colors'
+require_relative './unique_names_generator/dictionaries/languages'
+require_relative './unique_names_generator/dictionaries/names'
+require_relative './unique_names_generator/dictionaries/numbers'
+require_relative './unique_names_generator/dictionaries/star_wars'
+
+# UniqueNamesGenerator implementation
+module UniqueNamesGenerator
+  module_function
+
+  def generate(dictionaries, separator: '_', style: :lowercase, seed: nil, creativity: 0)
+    @separator = separator
+    @style = style
+    @seed = seed
+    @creativity = creativity
+
+    if creativity.negative? || creativity > 10
+      raise ArgumentError, 'Outside creativity range. Must be between 0 and 10.'
+    end
+
+    generate_name(dictionaries)
+  end
+
+  def match_word_list(dictionary)
+    module_name = camelize_dictionary(dictionary)
+    begin
+      dictionary = Dictionaries.const_get(module_name)
+      dictionary.list_all
+    rescue NameError
+      raise_invalid_dictionary(dictionary)
+    end
+  end
+
+  def word_list(dictionary)
+    case dictionary
+    when Array
+      dictionary if dictionary.all? { |item| item.is_a?(String) }
+    when Symbol
+      match_word_list(dictionary)
+    else
+      raise ArgumentError, 'Dictionary contains invalid dictionary type'
+    end
+  end
+
+  def random_seeded_float
+    seed_value = Seed.generate_seed(@seed)
+
+    prng = @seed.nil? ? Random.new : Random.new(seed_value)
+    prng.rand
+  end
+
+  def map_dictionaries(dictionaries)
+    dictionaries.map { |dictionary| word_list(dictionary) }
+  end
+
+  def split_with_separator(word)
+    if @separator.nil?
+      word.split(/(?=[A-Z])/)
+    else
+      word.split(@separator)
+    end
+  end
+
+  def format_parts(parts)
+    parts.map do |part|
+      if part.match?(/[^a-zA-Z]/) && @style == :capital
+        # Preserve original capitalization for parts with non-letter characters
+        part
+      else
+        format_word(part, @style)
+      end
+    end.join(@separator)
+  end
+
+  def format_multi_word(word, original_word)
+    if original_word.include?(' ') || original_word.include?('-')
+      parts = split_with_separator(word)
+      format_parts(parts)
+    else
+      format_word(word, @style)
+    end
+  end
+
+  def generate_name(dictionaries)
+    if @creativity.nil? || @creativity.zero?
+      generate_name_original(dictionaries)
+    else
+      generate_name_creatively(dictionaries)
+    end
+  end
+
+  def generate_name_original(dictionaries)
+    map_dictionaries(dictionaries).reduce(nil) do |acc, x|
+      rnd = (random_seeded_float * x.length).floor
+      original_word = x[rnd]
+
+      output_word(acc, original_word)
+    end
+  end
+
+  def generate_name_creatively(dictionaries)
+    word_lists = map_dictionaries(dictionaries)
+
+    word_lists.each_with_index.reduce(nil) do |acc, (word_list, index)|
+      creativity = calculate_creativity(index)
+      rnd = (random_seeded_float * word_list.length * creativity).floor
+      original_word = word_list[rnd % word_list.length] # Ensure we don't go out of bounds
+
+      output_word(acc, original_word)
+    end
+  end
+
+  def output_word(acc, original_word)
+    word = format_with_separator(original_word)
+    word = format_multi_word(word, original_word)
+
+    if acc
+      "#{acc}#{@separator}#{word}"
+    else
+      word
+    end
+  end
+
+  def calculate_creativity(index)
+    if index.zero?
+      @creativity # Base creativity for the first dictionary
+    else
+      @creativity * (2 + index * 0.5) # Increase creativity for subsequent dictionaries
+    end
+  end
+
+  def camelize_dictionary(dictionary)
+    dictionary.to_s.split('_').map(&:capitalize).join
+  end
+
+  def raise_invalid_dictionary(dictionary)
+    raise ArgumentError, "Invalid dictionary: #{dictionary}"
+  end
+
+  def format_with_separator(word)
+    if @separator.nil?
+      # If separator is empty, just remove spaces without changing case
+      word.gsub(/\s+/, '')
+    else
+      # If there's a separator, use it to replace spaces
+      word.gsub(/\s+/, @separator)
+    end
+  end
+
+  def format_word(word, style)
+    case style
+    when :lowercase
+      word.downcase
+    when :uppercase
+      word.upcase
+    when :capital
+      word.capitalize
+    else
+      word
+    end
+  end
+
+  private_class_method(
+    *%i[
+      generate_name
+      match_word_list
+      word_list
+      random_seeded_float
+      map_dictionaries
+      camelize_dictionary
+      raise_invalid_dictionary
+      format_with_separator
+      format_multi_word
+      format_parts
+      format_word
+      split_with_separator
+      generate_name_original
+      generate_name_creatively
+      calculate_creativity
+      output_word
+    ]
+  )
+end

data/unique_names_generator.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lib/unique_names_generator/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'unique_names_generator'
+  s.version       = UniqueNamesGenerator::VERSION
+  s.summary       = 'Ruby library for generating random and unique names'
+  s.description = <<~DESC
+    Generate random and unique names in Ruby with support for PRNG
+    seeded/deterministic generation using a built in collection of
+    dictionaries, or your own.
+  DESC
+  s.authors       = ['Jon Girard']
+  s.email         = 'jongirard03@gmail.com'
+  s.homepage      = 'https://github.com/jongirard/unique_names_generator_ruby'
+  s.metadata      = { 'homepage_uri' => 'https://github.com/jongirard/unique_names_generator_ruby',
+                      'source_code_uri' => 'https://github.com/jongirard/unique_names_generator_ruby' }
+  s.require_paths = ['lib']
+  s.license       = 'MIT'
+  s.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  s.required_ruby_version = '>= 2.6.0'
+
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: unique_names_generator
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Jon Girard
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  Generate random and unique names in Ruby with support for PRNG
+  seeded/deterministic generation using a built in collection of
+  dictionaries, or your own.
+email: jongirard03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ruby.yml"
+- ".pryrc"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/unique_names_generator.rb
+- lib/unique_names_generator/dictionaries/adjectives.rb
+- lib/unique_names_generator/dictionaries/animals.rb
+- lib/unique_names_generator/dictionaries/colors.rb
+- lib/unique_names_generator/dictionaries/languages.rb
+- lib/unique_names_generator/dictionaries/names.rb
+- lib/unique_names_generator/dictionaries/numbers.rb
+- lib/unique_names_generator/dictionaries/star_wars.rb
+- lib/unique_names_generator/seed.rb
+- lib/unique_names_generator/version.rb
+- unique_names_generator.gemspec
+homepage: https://github.com/jongirard/unique_names_generator_ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jongirard/unique_names_generator_ruby
+  source_code_uri: https://github.com/jongirard/unique_names_generator_ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Ruby library for generating random and unique names
+test_files: []