random_name_generator 1.0.1 → 2.0.0

data/lib/languages/goblin-ru.txt

@@ -0,0 +1,48 @@
+-ваа +c
+-боо +c
+-гар
+-бар
+-дар
+-жар
+-вар
+-кра
+-гра
+-дра
+-зра
+-гоб
+-доб
+-роб
+-фоб
+-зоб
+-раг
+-наг
+-даг
+бра
+га
+да
+до
+го
+зе
+ша
+наз
+зуб
+зу
+на
+гор
+бу +c
++быр
++гыр
++дыр
++выр
++зыр
++ыр -c
++зог
++рог
++гог
++ог -c
++гул
++дул
++бул
++рул
++ул -c
++ргх -v

data/lib/languages/roman-ru.txt

@@ -0,0 +1,35 @@
+-а
+-ал
+-ау +c
+-ан
+-ба
+-бе
+-би
+-бр +v
+-да
+-ди
+-до
+-ду
+-е
+-эу +c
+-фа
+би
+бе
+бо
+бу
+нул +v
+гу
+да
+ау +c -c
+фри
+гус
++тус
++лус
++лиус
++нус
++эс
++иус -c
++кус
++тор
++цио
++тин

data/lib/random_name_generator.rb

@@ -1,2 +1,150 @@
-require File.join(File.dirname(__FILE__), 'random_name_generator', 'random_name_generator')
-require File.join(File.dirname(__FILE__), 'random_name_generator', 'rng_syllable')
+# frozen_string_literal: true
+
+require_relative "random_name_generator/version"
+require_relative "random_name_generator/syllable"
+
+# RandomNameGenerator:
+#
+# Examples
+#
+#   rng = RandomNameGenerator::Generator.new(RandomNameGenerator::GOBLIN)
+#   puts rng.compose(3)
+#
+# By default RandomNameGenerator uses the Fantasy syllable file and creates a name with between 2 and 5 syllables.
+#
+#   rng = RandomNameGenerator::Generator.new
+#   puts rng.compose
+#
+# :reek:TooManyConstants
+# :reek:TooManyInstanceVariables
+# :reek:TooManyStatements
+module RandomNameGenerator
+  dirname = File.dirname(__FILE__)
+
+  ELVEN = File.new("#{dirname}/languages/elven.txt")
+  FANTASY = File.new("#{dirname}/languages/fantasy.txt")
+  GOBLIN = File.new("#{dirname}/languages/goblin.txt")
+  ROMAN = File.new("#{dirname}/languages/roman.txt")
+
+  ELVEN_RU = File.new("#{dirname}/languages/elven-ru.txt")
+  FANTASY_RU = File.new("#{dirname}/languages/fantasy-ru.txt")
+  GOBLIN_RU = File.new("#{dirname}/languages/goblin-ru.txt")
+  ROMAN_RU = File.new("#{dirname}/languages/roman-ru.txt")
+
+  # Experimental
+  CURSE = File.new("#{dirname}/languages/experimental/curse.txt")
+
+  # Static factory method that instantiates a RandomNameGenerator in a random language.
+  def self.flip_mode
+    langs = [RandomNameGenerator::FANTASY,
+             RandomNameGenerator::ELVEN,
+             RandomNameGenerator::GOBLIN,
+             RandomNameGenerator::ROMAN]
+    Generator.new(langs.sample)
+  end
+
+  # Static factory method that instantiates a RandomNameGenerator in a random
+  # Cyrillic based language.
+  def self.flip_mode_cyrillic
+    langs = [RandomNameGenerator::FANTASY_RU,
+             RandomNameGenerator::ELVEN_RU,
+             RandomNameGenerator::GOBLIN_RU,
+             RandomNameGenerator::ROMAN_RU]
+    Generator.new(langs.sample)
+  end
+
+  def self.pick_number_of_syllables(random: Random.new)
+    [2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5].sample(random: random)
+  end
+
+  # Static factory method for the Generator class.
+  def self.new(language = RandomNameGenerator::FANTASY, random: Random.new)
+    Generator.new(language, random: random)
+  end
+
+  # Generator
+  #
+  # Workhorse class that assembles names from dialect files.
+  #
+  class Generator
+    attr_reader :language, :pre_syllables, :sur_syllables, :mid_syllables
+
+    def initialize(language = RandomNameGenerator::FANTASY, random: Random.new)
+      @pre = nil
+      @language = language
+      @rnd = random
+      @pre_syllables = []
+      @mid_syllables = []
+      @sur_syllables = []
+
+      refresh
+    end
+
+    # Returns the composed name as an array of Syllables.
+    def compose_array(count = RandomNameGenerator.pick_number_of_syllables)
+      @pre = pre_syllables.sample(random: @rnd)
+      return @pre.to_s.capitalize if count < 2
+
+      name = determine_middle_syllables(count - 2, @pre)
+      name << determine_last_syllable(name.last)
+      name
+    end
+
+    def compose(count = RandomNameGenerator.pick_number_of_syllables)
+      compose_array(count).map(&:to_s).join.capitalize
+    end
+
+    def to_s
+      "RandomNameGenerator::Generator (#{@language.path.split("/")[-1]})"
+    end
+
+    private
+
+    def determine_middle_syllables(count, pre)
+      determine_next_syllables(count, pre, @mid_syllables)
+    end
+
+    def determine_last_syllable(next_to_last_syllable)
+      determine_next_syllable(next_to_last_syllable, @sur_syllables)
+    end
+
+    def determine_next_syllables(count, pre, syllables)
+      name = Array(pre)
+      return name if count < 1
+
+      next_syllable = pre
+      count.times do
+        next_syllable = determine_next_syllable(next_syllable, syllables)
+        name << next_syllable
+      end
+      name
+    end
+
+    def determine_next_syllable(this_syllable, sampler)
+      next_syllable = ""
+      loop do
+        next_syllable = sampler.sample(random: @rnd)
+        break unless this_syllable.incompatible?(next_syllable)
+      end
+      next_syllable
+    end
+
+    # Loops through the language file, and pushes each syllable into the correct array.
+    def refresh
+      @language.readlines.each do |line|
+        push(RandomNameGenerator::Syllable.new(line)) unless line.empty?
+      end
+      @language.rewind
+    end
+
+    def push(syllable)
+      if syllable.prefix?
+        @pre_syllables.push(syllable)
+      elsif syllable.suffix?
+        @sur_syllables.push(syllable)
+      else
+        @mid_syllables.push(syllable)
+      end
+    end
+  end
+end

data/lib/random_name_generator/syllable.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RandomNameGenerator
+  # Syllable: Class for managing properties of individual syllables with in language name file. Each line within a file
+  # translates into a syllable object. The reason behind this class is to take over most of the complexity of parsing each
+  # syllable, greatly simplifying the work done by RandomNameGenerator. This code is not meant to be called directly as a
+  # part of standard usage.
+  #
+  # Examples
+  #
+  #   syllable = Syllable.new('-foo +c')
+  #
+  # This creates a foo syllable object that needs to be the first syllable and followed by a constant.
+  #
+  # For testing purposes, passing in another Syllable object will create a clone:
+  #
+  #   syllable_clone = Syllable.new(syllable)
+  #
+  # SYLLABLE CLASSIFICATION:
+  # Name is usually composed from 3 different class of syllables, which include prefix, middle part and suffix.
+  # To declare syllable as a prefix in the file, insert "-" as a first character of the line.
+  # To declare syllable as a suffix in the file, insert "+" as a first character of the line.
+  # everything else is read as a middle part.
+  #
+  # NUMBER OF SYLLABLES:
+  # Names may have any positive number of syllables. In case of 2 syllables, name will be composed from prefix and suffix.
+  # In case of 1 syllable, name will be chosen from amongst the prefixes.
+  # In case of 3 and more syllables, name will begin with prefix, is filled with middle parts and ended with suffix.
+  #
+  # ASSIGNING RULES:
+  # I included a way to set 4 kind of rules for every syllable. To add rules to the syllables, write them right after the
+  # syllable and SEPARATE WITH WHITESPACE. (example: "aad +v -c"). The order of rules is not important.
+  #
+  # RULES:
+  # 1) +v means that next syllable must definitely start with a vowel.
+  # 2) +c means that next syllable must definitely start with a consonant.
+  # 3) -v means that this syllable can only be added to another syllable, that ends with a vowel.
+  # 4) -c means that this syllable can only be added to another syllable, that ends with a consonant.
+  #
+  # :reek:TooManyMethods
+  # :reek:TooManyInstanceVariables
+  class Syllable
+    attr_reader :raw, :syllable, :next_syllable_requirement, :previous_syllable_requirement
+
+    VOWELS = %w[i y ɨ ʉ ɯ u ɪ ʏ ʊ ɯ ʊ e ø ɘ ɵ ɤ o ø ə ɵ ɤ o ɛ œ ɜ ɞ ʌ ɔ æ ɐ ɞ a ɶ ä ɒ ɑ].freeze
+    CONSONANTS = %w[b ɓ ʙ β c d ɗ ɖ ð f g h j k l ł m ɱ n ɳ p q r s t v w x y z].freeze
+
+    def initialize(args)
+      @raw = args.strip
+      @syllable = ""
+      @is_prefix = false
+      @is_suffix = false
+      @next_syllable_requirement = :letter
+      @previous_syllable_requirement = :letter
+
+      if args.is_a?(Syllable)
+        parse_args(args.raw)
+      else
+        parse_args(args)
+      end
+    end
+
+    def incompatible?(next_syllable)
+      (next_incompatible?(next_syllable) || previous_incompatible?(next_syllable))
+    end
+
+    def compatible?(next_syllable)
+      !incompatible?(next_syllable)
+    end
+
+    def prefix?
+      @is_prefix
+    end
+
+    def suffix?
+      @is_suffix
+    end
+
+    def consonant_first?
+      CONSONANTS.include?(syllable[0])
+    end
+
+    def vowel_first?
+      VOWELS.include?(syllable[0])
+    end
+
+    def consonant_last?
+      CONSONANTS.include?(syllable[-1])
+    end
+
+    def vowel_last?
+      VOWELS.include?(syllable[-1])
+    end
+
+    def next_syllable_universal?
+      @next_syllable_requirement == :letter
+    end
+
+    def next_syllable_must_start_with_vowel?
+      @next_syllable_requirement == :vowel
+    end
+
+    def next_syllable_must_start_with_consonant?
+      @next_syllable_requirement == :consonant
+    end
+
+    def previous_syllable_universal?
+      @previous_syllable_requirement == :letter
+    end
+
+    def previous_syllable_must_end_with_vowel?
+      @previous_syllable_requirement == :vowel
+    end
+
+    def previous_syllable_must_end_with_consonant?
+      @previous_syllable_requirement == :consonant
+    end
+
+    def to_s
+      @syllable
+    end
+
+    def to_str
+      @syllable
+    end
+
+    private
+
+    # :reek:FeatureEnvy
+    def parse_args(args)
+      args = args.to_s.strip.downcase.split
+      parse_syllable(args[0])
+      parse_flags(args[1..-1])
+    end
+
+    def parse_syllable(syll)
+      raise ArgumentError "Empty String is not allowed." if syll.empty?
+
+      captures = /([+-]?)(.+)/.match(syll).captures
+      parse_prefix(captures[0])
+      @syllable = captures[1]
+    end
+
+    # :reek:ControlParameter
+    def parse_prefix(prefix)
+      case prefix
+      when "-"
+        @is_prefix = true
+      when "+"
+        @is_suffix = true
+      end
+    end
+
+    def parse_flags(flags)
+      if flags.include?("+v")
+        @next_syllable_requirement = :vowel
+      elsif flags.include?("+c")
+        @next_syllable_requirement = :consonant
+      end
+      if flags.include?("-v")
+        @previous_syllable_requirement = :vowel
+      elsif flags.include?("-c")
+        @previous_syllable_requirement = :consonant
+      end
+    end
+
+    def next_incompatible?(next_syllable)
+      vnc = (next_syllable_must_start_with_vowel? && next_syllable.consonant_first?)
+      cnv = (next_syllable_must_start_with_consonant? && next_syllable.vowel_first?)
+
+      (vnc || cnv)
+    end
+
+    def previous_incompatible?(next_syllable)
+      vlc = (vowel_last? && next_syllable.previous_syllable_must_end_with_consonant?)
+      clv = (consonant_last? && next_syllable.previous_syllable_must_end_with_vowel?)
+
+      (vlc || clv)
+    end
+  end
+end

data/lib/random_name_generator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RandomNameGenerator
+  VERSION = "2.0.0"
+end

data/random_name_generator.gemspec

@@ -1,24 +1,35 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+# frozen_string_literal: true
+
+require_relative "lib/random_name_generator/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'random_name_generator'
-  spec.version       = '1.0.1'
-  spec.authors       = ['folkengine']
-  spec.email         = ['gaoler@electronicpanopticon.com']
-  spec.licenses      = ['GPL-3.0']
+  spec.name          = "random_name_generator"
+  spec.version       = RandomNameGenerator::VERSION
+  spec.authors       = ["folkengine"]
+  spec.email         = ["gaoler@electronicpanopticon.com"]
+
+  spec.summary       = "Random Name Generator"
+  spec.description   = "Generates random names based upon custom collections of syllables. Styles include Elvish, Fantasy, Goblin, and Roman."
+  spec.homepage      = "https://github.com/folkengine/random_name_generator"
+  spec.license       = "LGPL-3.0"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/folkengine/random_name_generator"
+  spec.metadata["changelog_uri"] = "https://github.com/folkengine/random_name_generator/CHANGELOG.md"
 
-  spec.summary       = 'Random Name Generator'
-  spec.description   = 'Generates random names based upon custom collections of syllables. Styles include Elvish, Fantasy, Goblin, and Roman'
-  spec.homepage      = 'https://github.com/folkengine/random_name_generator'
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
 
-  spec.required_ruby_version = '>= 2.1.5'
-  spec.add_development_dependency 'bundler', '~> 1.11'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
 end