glossa 1.0.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d95abe526ac1d302f6a15983c96abb8abd8513a
-  data.tar.gz: 7a16c7b7576caa1a7652300af8b8f1be063abb21
+  metadata.gz: 2b406d8728b2b832e70c3aefc528020eb5489c53
+  data.tar.gz: 6ad10f3b86df8dc9d899618e2c4c8635e9ba4230
 SHA512:
-  metadata.gz: 61489793e6306cd7a57c5cfefc7405f552b7a005ff88db37ac22682e3bd44b3b9108e727c1e4b66565c6c1ec07dbc76d7f983bdd6af6e85b0907599a8d3d358f
-  data.tar.gz: a3461b9ad1c714787180f340eae82f676bd6d08263f9baa83c6ae251d9bdaf7d368a7e675610f23aa6b8b76aba280cf25b45dee02937f7f9b2e3560a62a17224
+  metadata.gz: 04e73fdf24aa45f3faf3b1c93c53296e5aaeccb4be50085bfcbd13801032402c9afad2feb7300a59a904afeb2da5df9be24f99b9fabc107c9b8f07d1179f69cd
+  data.tar.gz: cc25218879756c1abe1bfa35cea4d5b24a022f6e0520e1a7d6bb5fd08099be14e944f9dfae2d4bc595814f0ac99e78daec13834f312ca4c94126898d74954c57

data/lib/glossa/language.rb

@@ -0,0 +1,314 @@
+class Glossa::Language
+	attr_accessor :phonemes, :structure, :exponent, :restricts, :cortho, :vortho, :noortho, :nomorph, :nowordpool, :minsyll, :maxsyll, :morphemes, :words, :names, :genitive, :definitive, :joiner, :maxchar, :minchar
+
+	def initialize(random = false, options = nil)
+		if random
+			@phonemes = {
+				"C" => shuffle(choose(Glossa::CON_SETS, 2)[:C]),
+				"V" => shuffle(choose(Glossa::VOW_SETS, 2)[:V]),
+				"L" => shuffle(choose(Glossa::L_SETS, 2)[:L]),
+				"S" => shuffle(choose(Glossa::S_SETS, 2)[:S]),
+				"F" => shuffle(choose(Glossa::F_SETS, 2)[:F])
+			}
+		    @noortho 	= false
+		    @nomorph 	= false
+		    @nowordpool = false
+		    @structure 	= choose(Glossa::SYLL_STRUCTS)
+		    @exponent	= rand(1..3) # a larger exponent means less variation when randomly choosing some elements
+		    @restricts 	= Glossa::RESTRICT_SETS[2][:res]
+		    @cortho 	= choose(Glossa::C_ORTH_SETS, 2)[:orth]
+		    @vortho 	= choose(Glossa::V_ORTH_SETS, 2)[:orth]
+		    @morphemes 	= {}
+		    @words		= {}
+		    @names		= []
+		    @joiner 	= choose('   -')
+		    @maxchar 	= rand(10...15)
+			@minchar 	= rand(3...5)
+		    @minsyll 	= rand(1...3)
+		    @maxsyll 	= rand(@minsyll + 1...7)
+
+		    if @structure.length < 3
+		    	@minsyll += 1;
+		    end
+		else
+		    options ||= {}
+			@phonemes 	= options[:phonemes] 	|| {
+	            "C" => "ptkmnls",
+	            "V" => "aeiou",
+	            "S" => "s",
+	            "F" => "mn",
+	            "L" => "rl"
+	        }
+			@structure 	= options[:structure] 	|| "CVC"
+			@exponent 	= options[:exponent] 	|| 2
+			@restricts 	= options[:restricts] 	|| []
+			@cortho 	= options[:cortho] 		|| {}
+			@vortho 	= options[:vortho] 		|| {}
+			@noortho 	= options[:noortho] 	|| true
+			@nomorph 	= options[:nomorph] 	|| true
+			@nowordpool = options[:nowordpool] 	|| true
+			@minsyll 	= options[:minsyll] 	|| 1
+			@maxsyll 	= options[:maxsyll] 	|| 1
+			@morphemes 	= options[:morphemes] 	|| {}
+			@words 		= options[:words] 		|| {}
+			@names 		= options[:names] 		|| []
+			@joiner 	= options[:joiner] 		|| ' '
+			@maxchar 	= options[:maxchar] 	|| 12
+			@minchar 	= options[:minchar] 	|| 5
+		end
+
+		@genitive 	= get_morpheme('of')
+		@definitive	= get_morpheme('the')
+	end
+
+	##
+	# Takes an array and picks a semi-random element, with the first
+	# elements weighted more frequently the the last elements by using
+	# the power of a given exponent.
+	def choose(list, exponent = 1)
+		listIndex = ((rand ** exponent) * list.length).floor
+
+		list[listIndex]
+	end
+
+	##
+	# Takes an array or string and shuffles it into a random order.
+	def shuffle(list)
+		is_string = list.is_a? String
+		l = is_string ? list.chars : list
+		new_list = l.dup
+
+		i = 0;
+		l.each do |item|
+			tmp = item
+			rand_index = rand(i)
+			new_list[i] = new_list[rand_index]
+			new_list[rand_index] = tmp
+			i += 1;
+		end
+
+		if is_string
+			return new_list.join
+		else
+			return new_list
+		end
+	end
+
+	##
+	# Takes an array of strings and an optional joiner string
+	# and concatenates them into a single string
+	def join(list, sep = '')
+		return '' if list.length == 0
+		first_word = list.shift
+		list.each do |item|
+			first_word << sep << item
+		end
+
+		first_word
+	end
+
+	##
+	# Takes an array of phonetic syllables, and spells them using the languages orthography
+	def spell(syllables)
+		return syllables if self.noortho
+		s = syllables.chars
+		word = ''
+		s.each do |syllable|
+			if self.cortho[syllable]
+				word << self.cortho[syllable]
+			elsif self.vortho[syllable]
+				word << self.vortho[syllable]
+			elsif Glossa::DEFAULT_ORTHO[syllable]
+				word << Glossa::DEFAULT_ORTHO[syllable]
+			else
+				word << syllable
+			end
+		end
+		word
+	end
+
+	##
+	# Creates a spelled (see the spell() method) syllable, according to
+	# the language's syllable structure. It does this by selecting a semi-random
+	# phonetic letter for the appropriate phoneme type in the structure, making sure
+	# that it doesn't conflict with a restricted pattern, and then spells the
+	# phonetic word according to the language's orthography.
+	def make_syllable
+		structure = self.structure.chars
+		while true
+			syll = ''
+			structure.each do |ptype|
+				# If the char is '?', skip with 50% chance to remove last character
+				# (think RegEx usage of '?')
+				if ptype == '?'
+					if rand < 0.5
+						syll = syll[0...syll.length - 1]
+					end
+					next
+				end
+				
+				syll << choose(self.phonemes[ptype], self.exponent)
+			end
+
+			# Make sure this syllable doesn't violate a restriction
+			bad = false
+			self.restricts.each do |regex|
+				if regex =~ syll
+					bad = true
+					break
+				end
+			end
+			next if bad
+
+			return spell(syll)
+		end
+	end
+
+	##
+	# The lowest common-denominator "word" that we will store for our language.
+	# Morphemes are the smallest unit of language that has a meaning.
+	# A "morpheme," in this sense, is a unique syllable (spelled according to our orthography)
+	# with a type (key). Whenever a morpheme is created, we store it in the class instance,
+	# so as to make sure we don't create duplicates. Morphemes comprise words.
+	def get_morpheme(key = '')
+		return make_syllable if self.nomorph
+
+		# make_word will sometimes pass in nil
+		if key.nil? 
+			key = ''
+		end
+
+		# Use the morphemes we've already made for this kind of word if possible
+		list = self.morphemes[key] || []
+
+		# If a key is not specified, make 10 generic morphemes
+		# otherwise, just make one new one
+		extras = key == '' ? 10 : 1
+
+		while true
+			# As more morphemes are created, there is a
+			# diminishing chance that a new one will be created.
+			n = rand(list.length + extras)
+			return list[n] if list[n]
+
+			# An existing morpheme was not selected, so create a new one
+			morph = make_syllable
+
+			# No duplicates!
+			bad = false
+			self.morphemes.each do |k|
+				next if self.morphemes[k].nil?
+				if self.morphemes[k].include? morph
+					bad = true
+					break
+				end
+			end
+			next if bad
+			list << morph
+			self.morphemes[key] = list
+
+			return morph
+		end
+	end
+
+	##
+	# Given the min- and max-syllables for our language, create a new
+	# word out of a random number of morphemes.
+	def make_word(key)
+		num_sylls = rand(self.minsyll..self.maxsyll)
+		word = ''
+		keys = []
+
+		# If a key is defined, then select one of the syllables
+		# to have a morpheme of that type.
+		keys[rand(num_sylls)] = key
+		num_sylls.times { |i| word << get_morpheme(keys[i]) }
+
+		word
+	end
+
+	##
+	# This method has a chance to use an existing word, or create a new
+	# one of the type (key) specified using the make_word method. If a
+	# new word is created, it will make sure that it is not duplicating
+	# an existing word, and then add it to the list of stored words.
+	def get_word(key = '')
+		words = self.words[key] || []
+		extras = key == '' ? 2 : 3
+
+		while true
+			n = rand(words.length + extras)
+			existing_word = words[n]
+			return existing_word if existing_word
+
+			new_word = make_word(key)
+			bad = false
+			self.words.each do |word|
+				if word.include? new_word
+					bad = true
+					break
+				end
+			end
+			next if bad
+			words << new_word
+			self.words[key] = words
+
+			return new_word
+		end
+	end
+
+	##
+	# A wrapper with some additional logic around the get_word method.
+	# make_name will create a name, using get_word (so the words created
+	# to make up the name will be saved by the specified key), and have
+	# a 50% chance to add an additional word, and potentially the genitive
+	# and definitive words. After checking to make sure that it's an ok size
+	# and isn't already used, it saves and returns the name
+	def make_name(key = '')
+		## If you don't dup these, words will get concatenated onto them during the join process
+		genitive = self.genitive.dup
+		definitive = self.definitive.dup
+
+		while true
+			# 50% chance that the name will be a single word, 50% chance that it will be two words combined somehow
+			name = rand < 0.5 ? get_word(key) : nil
+			if name.nil?
+				# 60% chance that each word will use the same key as invoked
+				w1_key = rand < 0.6 ? key : ''
+				w1 = get_word(w1_key).capitalize
+				w2_key = rand < 0.6 ? key : ''
+				w2 = get_word(w2_key).capitalize
+
+				# 50% chance to be joined without the lang's genitive word
+				if rand > 0.5
+					name = join([w1, w2], self.joiner)
+				else
+					name = join([w1, genitive, w2], self.joiner)
+				end
+			end
+
+			# 10% to prefix with definitive
+			name = join([definitive, name], self.joiner) if rand < 0.1
+
+			# Generate another one if this doesn't meet the min- or maxchar reqs
+			next if (name.length < self.minchar) || (name.length > self.maxchar)
+
+			name.capitalize!
+
+			# Check to see if this string has already been generated
+			used = false
+			self.names.each do |lang_name|
+				if (name.include? lang_name) || (lang_name.include? name)
+					used = true
+					break
+				end
+			end
+
+			# Start over if this name exists already
+			next if used
+
+			self.names << name
+			return name
+		end
+	end
+end

data/lib/glossa.rb

@@ -256,316 +256,6 @@ module Glossa
 	        :res => [/[sʃf][sʃ]/, /(.)\1/, /[rl][rl]/]
 	    }
 	]
+end
 
-	class Language
-		attr_accessor :phonemes, :structure, :exponent, :restricts, :cortho, :vortho, :noortho, :nomorph, :nowordpool, :minsyll, :maxsyll, :morphemes, :words, :names, :genitive, :definitive, :joiner, :maxchar, :minchar
-
-		def initialize(random = false, options = nil)
-			if random
-				@phonemes = {
-					"C" => shuffle(choose(CON_SETS, 2)[:C]),
-					"V" => shuffle(choose(VOW_SETS, 2)[:V]),
-					"L" => shuffle(choose(L_SETS, 2)[:L]),
-					"S" => shuffle(choose(S_SETS, 2)[:S]),
-					"F" => shuffle(choose(F_SETS, 2)[:F])
-				}
-			    @noortho 	= false
-			    @nomorph 	= false
-			    @nowordpool = false
-			    @structure 	= choose(SYLL_STRUCTS)
-			    @exponent	= rand(1..3)
-			    @restricts 	= RESTRICT_SETS[2][:res]
-			    @cortho 	= choose(C_ORTH_SETS, 2)[:orth]
-			    @vortho 	= choose(V_ORTH_SETS, 2)[:orth]
-			    @morphemes 	= {}
-			    @words		= {}
-			    @names		= []
-			    @joiner 	= choose('   -')
-			    @maxchar 	= rand(10...15)
-				@minchar 	= rand(3...5)
-			    @minsyll 	= rand(1...3)
-			    @maxsyll 	= rand(@minsyll + 1...7)
-
-			    if @structure.length < 3
-			    	@minsyll += 1;
-			    end
-			else
-			    options ||= {}
-				@phonemes 	= options[:phonemes] 	|| {
-		            "C" => "ptkmnls",
-		            "V" => "aeiou",
-		            "S" => "s",
-		            "F" => "mn",
-		            "L" => "rl"
-		        }
-				@structure 	= options[:structure] 	|| "CVC"
-				@exponent 	= options[:exponent] 	|| 2
-				@restricts 	= options[:restricts] 	|| []
-				@cortho 	= options[:cortho] 		|| {}
-				@vortho 	= options[:vortho] 		|| {}
-				@noortho 	= options[:noortho] 	|| true
-				@nomorph 	= options[:nomorph] 	|| true
-				@nowordpool = options[:nowordpool] 	|| true
-				@minsyll 	= options[:minsyll] 	|| 1
-				@maxsyll 	= options[:maxsyll] 	|| 1
-				@morphemes 	= options[:morphemes] 	|| {}
-				@words 		= options[:words] 		|| {}
-				@names 		= options[:names] 		|| []
-				@joiner 	= options[:joiner] 		|| ' '
-				@maxchar 	= options[:maxchar] 	|| 12
-				@minchar 	= options[:minchar] 	|| 5
-			end
-
-			@genitive 	= get_morpheme('of')
-			@definitive	= get_morpheme('the')
-		end
-
-		##
-		# Takes an array and picks a semi-random element, with the first
-		# elements weighted more frequently the the last elements by using
-		# the power of a given exponent.
-		def choose(list, exponent = 1)
-			listIndex = ((rand ** exponent) * list.length).floor
-
-			list[listIndex]
-		end
-
-		##
-		# This is already how rand works? Need to verify
-		def rand_range(lo, hi = nil)
-			if hi.nil?
-				hi = lo
-				lo = 0
-			end
-
-			(rand * (hi - lo) + lo).floor
-		end
-
-		##
-		# Takes an array or string and shuffles it into a random order.
-		def shuffle(list)
-			is_string = list.is_a? String
-			l = is_string ? list.chars : list
-			new_list = l.dup
-
-			i = 0;
-			l.each do |item|
-				tmp = item
-				rand_index = rand(i)
-				new_list[i] = new_list[rand_index]
-				new_list[rand_index] = tmp
-				i += 1;
-			end
-
-			if is_string
-				return new_list.join
-			else
-				return new_list
-			end
-		end
-
-		##
-		# Takes an array of strings and an optional joiner string
-		# and concatenates them into a single string
-		def join(list, sep = '')
-			return '' if list.length == 0
-			first_word = list.shift
-			list.each do |item|
-				first_word << sep << item
-			end
-
-			first_word
-		end
-
-		##
-		# Takes an array of phonetic syllables, and spells it using the languages orthography
-		def spell(syllables)
-			return syllables if self.noortho
-			s = syllables.chars
-			word = ''
-			s.each do |syllable|
-				if self.cortho[syllable]
-					word << self.cortho[syllable]
-				elsif self.vortho[syllable]
-					word << self.vortho[syllable]
-				elsif DEFAULT_ORTHO[syllable]
-					word << DEFAULT_ORTHO[syllable]
-				else
-					word << syllable
-				end
-			end
-			word
-		end
-
-		##
-		# Creates a spelled (see the spell() method) syllable, according to
-		# the language's syllable structure. It does this by selecting a semi-random
-		# phonetic letter for the appropriate phoneme type in the structure, making sure
-		# that it doesn't conflict with a restricted pattern, and then spells the
-		# phonetic word according to the language's orthography.
-		def make_syllable
-			structure = self.structure.chars
-			while true
-				syll = ''
-				structure.each do |ptype|
-					# If the char is '?', skip with 50% chance to remove last character
-					if ptype == '?'
-						if rand < 0.5
-							syll = syll[0...syll.length - 1]
-						end
-						next
-					end
-					
-					syll << choose(self.phonemes[ptype], self.exponent)
-				end
-				bad = false
-				self.restricts.each do |regex|
-					if regex =~ syll
-						bad = true
-						break
-					end
-				end
-				next if bad
-
-				return spell(syll)
-			end
-		end
-
-		##
-		# The lowest common-denominator "word" that we will store for our language.
-		# Morphemes are the smallest unit of language that has a meaning.
-		# A "morpheme," in this sense, is a unique syllable (spelled according to our orthography)
-		# with a type (key). Whenever a morpheme is created, we store it in the class instance,
-		# so as to make sure we don't create duplicates. Morphemes comprise words.
-		def get_morpheme(key = '')
-			return make_syllable if self.nomorph
-
-			# Use the morphemes we've already made for this kind of word if possible
-			list = self.morphemes[key] || []
-
-			# If a key is not specified, make 10 generic morphemes
-			# otherwise, just make one new one
-			extras = key == '' ? 10 : 1
-
-			while true
-				# As more morphemes are created, there is a
-				# diminishing chance that a new one will be created.
-				n = rand_range(list.length + extras)
-				return list[n] if list[n]
-
-				morph = make_syllable
-
-				# No duplicates!
-				bad = false
-				self.morphemes.each do |k|
-					next if self.morphemes[k].nil?
-					if self.morphemes[k].include? morph
-						bad = true
-						break
-					end
-				end
-				next if bad
-				list << morph
-				self.morphemes[key] = list
-
-				return morph
-			end
-		end
-
-		##
-		# Given the min- and max-syllables for our language, create a new
-		# word out of a random number of morphemes.
-		def make_word(key)
-			num_sylls = rand_range(self.minsyll, self.maxsyll + 1)
-			word = ''
-			keys = []
-
-			# If a key is defined, then select one of the syllables
-			# to have a morpheme of that type.
-			keys[rand_range(num_sylls)] = key
-			num_sylls.times { |i| word << get_morpheme(keys[i]) }
-
-			word
-		end
-
-		##
-		# This method has a chance to use an existing word, or create a new
-		# one of the type (key) specified using the make_word method. If a
-		# new word is created, it will make sure that it is not duplicating
-		# an existing word, and then add it to the list of stored words.
-		def get_word(key = '')
-			words = self.words[key] || []
-			extras = key == '' ? 2 : 3
-
-			while true
-				n = rand_range(words.length + extras)
-				existing_word = words[n]
-				return existing_word if existing_word
-
-				new_word = make_word(key)
-				bad = false
-				self.words.each do |word|
-					if word.include? new_word
-						bad = true
-						break
-					end
-				end
-				next if bad
-				words << new_word
-				self.words[key] = words
-
-				return new_word
-			end
-		end
-
-		##
-		# A wrapper with some additional logic around the get_word method.
-		# make_name will create a name, using get_word (so the words created
-		# to make up the name will be saved by the specified key), and have
-		# a 50% chance to add an additional word, and potentially the genitive
-		# and definitive words. After checking to make sure that it's an ok size
-		# and isn't already used, it saves and returns the name
-		def make_name(key = '')
-			## If you don't dup these, words will get concatenated onto them during the join process
-			genitive = self.genitive.dup
-			definitive = self.definitive.dup
-			puts self.definitive
-			while true
-				# 50% chance that the name will be a single word, 50% chance that it will be two words combined somehow
-				name = rand < 0.5 ? get_word(key) : nil
-				if name.nil?
-					# 60% chance that each word will use the same key as invoked
-					w1_key = rand < 0.6 ? key : ''
-					w1 = get_word(w1_key).capitalize
-					w2_key = rand < 0.6 ? key : ''
-					w2 = get_word(w2_key).capitalize
-
-					# 50% chance to be joined without the lang's genitive word
-					if rand > 0.5
-						name = join([w1, w2], self.joiner)
-					else
-						name = join([w1, genitive, w2], self.joiner)
-					end
-				end
-
-				# 10% to prefix with definitive
-				name = join([definitive, name], self.joiner) if rand < 0.1
-				puts self.definitive
-				next if (name.length < self.minchar) || (name.length > self.maxchar)
-
-				used = false
-				self.names.each do |lang_name|
-					if (name.include? lang_name) || (lang_name.include? name)
-						used = true
-						break
-					end
-				end
-
-				next if used
-
-				self.names << name.capitalize
-				return name.capitalize
-			end
-		end
-	end
-end
+require "glossa/language"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glossa
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Jake Franklin
@@ -10,14 +10,17 @@ bindir: bin
 cert_chain: []
 date: 2017-03-11 00:00:00.000000000 Z
 dependencies: []
-description: glossa is a tool for creating simple naming language generators (which
-  can in turn generate names)
+description: |-
+  Glossa is a tool for creating simple naming language generators (which can in turn generate names).
+
+    Note: Version 1.0.0 is an (almost) direct port of [mewo2's JavaScript naming-language generator](https://github.com/mewo2/naming-language). These initial ideas are his, and I have changed very little of the actual inner-workings (other than basically turn it into a class). I would _*highly*_ encourage everybody to go and checkout his original repo (link above), [read his documentation on how the language generator works](http://mewo2.com/notes/naming-language/), and [follow @unchartedatlas](https://twitter.com/unchartedatlas)
 email: jacob.d.franklin@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/glossa.rb
+- lib/glossa/language.rb
 homepage: http://rubygems.org/gems/glossa
 licenses:
 - MIT
@@ -41,5 +44,5 @@ rubyforge_project:
 rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: A random naming language generator generator
+summary: A random naming language generator
 test_files: []