jmadlibs 0.8.5 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70bb528dc1a0d1055a27ad44eda45f83f249e79e
-  data.tar.gz: fae188b16c19d5216101ba0b679e4b032ef76545
+  metadata.gz: 1aec2baf45a205e130f6e95d2bfecbb28a6bbccc
+  data.tar.gz: e63a3fb08afd81dd9fffdc3c65851b73bf3eca2a
 SHA512:
-  metadata.gz: 51888365ff2bf0092ef38faf4627e72160d31e911c5165fa96d4d916538a3826d2e50238aeff5d55043a7e20eaef853fa8405c5382d49a83e205102ccc5042be
-  data.tar.gz: 56992191263a7624c9028888793830efc5b10c9b0aba6046cf9ad4bb3a43ab2cd1bddeb0b80e8283391eb4c28dd6cb378240c9d32a30a3d566bc5a55513020da
+  metadata.gz: c300dff0dc468dc74c05a20d4860365dac2fe1721bfd34abe5fe491eba2eba214196e6d82a15cc10dd499d4ad84572a7189e9599bf05c6a90f62d83f0e563775
+  data.tar.gz: 4d64216506bd0c1cea07a6f52221366492dd15836dc49fdb75006c538474ce3bb4684bfd8e12da42cbc0f5ea21531f3f5b22ae52375a4facc1db04147e70041f

data/lib/jmadlibs.rb

@@ -9,7 +9,7 @@
 #     > <wordlist%a> prepends a/an based on first letter of returned word
 #     > capitalised substitutions: <Wordlist>
 #
-# * joins between two lists: <lista+listb>
+#   * joins between two lists: <lista+listb>
 
 # All of the above can be combined and appear in the results of a parsing,
 # so having any operator appear in a substitution word list is possible.
@@ -18,15 +18,19 @@
 # * Currently, {{alt aa|alt ab}|{alt ba|alt bb}} will fail. Regex needs work.
 # * add pluralisation: bike->bikes, boss->bosses, fox->foxes, etc. https://en.wikipedia.org/wiki/English_plurals
 # * \ escaping of token signifiers. For instance, \[thing] treated as plaintext
+# * Redo <lista+listb> parsing to use list lengths and random index generation rather than current concatenation of
+#   copies.
+# * Look into allowing $0-9 specifiers per-list in <lista+listb> constructions
 
 
 class JMadlibs
-  def initialize(pattern=nil, library=nil)
+  def initialize(pattern=nil, library=nil, variantString = "")
     @loglevels = {0 => "NONE", 1 => "ERROR", 2 => "WARN", 3 => "INFO", 4 => "DEBUG", 5 => "ALL"}
 	@loglevel = 3
     @rng = Random.new
     setPattern(pattern)
     setLibrary(library)
+    setVariants(variantString)
   end
 
   def log(msg, priority=5)
@@ -54,6 +58,10 @@ class JMadlibs
 	end
   end
 
+  def setVariants(variantString)
+    @variants = variantString
+  end
+
   def setLogLevel(loglevel)
     if loglevel.is_a? String then loglevel = @loglevels.key(loglevel) end
     @loglevel = loglevel
@@ -62,23 +70,23 @@ class JMadlibs
 
   def loadList(filename)
     if File.file?(filename)
-	  log "Loading word lists from " + filename, "INFO"
+      log "Loading word lists from " + filename, "INFO"
       @library = {}
       currentList = ""
-	  currentListContents = []
+      currentListContents = []
 
       File.foreach(filename).with_index do |line|
         line = line.strip
         if line != "" and !line.start_with?('#')
           matched = /^==(.+)==$/.match(line)
           if !matched.nil? # new list identifier
-		    if currentList != "" # save old list, if one exists.
-			  addList(currentList, currentListContents)
-			end
+            if currentList != "" # save old list, if one exists.
+              addList(currentList, currentListContents)
+            end
             currentList = matched[1] # update working targets for new list
             currentListContents = []
           elsif currentList == "" # we have no current list; this must be a pattern
-			setPattern(line)
+            setPattern(line)
           else # word to be added to current list
             currentListContents.push(line)
           end
@@ -90,14 +98,72 @@ class JMadlibs
     end
   end
 
-  def anify(word) # If word begins with a vowel, prefix 'an', else prefix 'a'
+  def anify(word) # If word begins with a vowel, prefix 'an ', else prefix 'a '
     if (/^[aeiou]/.match(word).nil?)
       result = "a " + word
 	else
       result = "an " + word
 	end
 
-	return result
+    return result
+  end
+
+  def getSpecified(word, specifier = nil) # get the correct representation of a word
+    #TODO: Convert ex. marry^marries^married^marrying to specified subword, return first if no specifier
+
+    # find default
+    options = word.count("\^")
+
+    if options == 0 # no variants exist
+      return word
+    end
+
+    default = word[0..word.index("^")-1]
+
+    if specifier.nil?
+      return default
+    end
+
+    variant = 0
+
+    if !specifier.index(/[0-9]/).nil? 
+      variant = specifier.to_i
+    else
+      variant = @variants.index(specifier)
+    end
+
+    if variant.nil?
+      log "Unknown variant identifier '" + specifier + "', using default.", 3
+      return default
+    end
+
+    start = 0
+
+    if variant >= options 
+      log "Unknown variant identifier '" + variant.to_s + "', using default.", 3
+      return default
+    end
+
+
+    for i in 0..variant # find start of correct option
+       start = word.index("^", start+1)
+    end
+
+    finish = word.index("^", start+1)
+
+    result = ""
+
+    if finish.nil?
+      result = word[start+1..-1]
+    else
+      result = word[start+1..finish-1]
+    end
+
+    if result.empty?
+      return default
+    else
+       return result
+    end
   end
 
   def pluralise(word)
@@ -108,24 +174,25 @@ class JMadlibs
 	# o -> oes
     # (se?)(sh)(ch)
 
-    # this is a pretty big problem!
+    # this is a pretty big problem!  POssibly solvable with getSpecified instead.
     return word
   end
 
   def resolve_substitution(target)
     up = false
-	specifier = ""
+    specifiers = ""
 
     # do we need to do post-processing?
-    post = target.rindex(/\$[ap]/)
+    post = target.rindex(/\$[a-zA-Z0-9]+/)
 
     if !post.nil?
-      specifier = target.slice(post+1, target.length - post - 1)
+      specifiers = target.slice(post+1, target.length - post - 1)
+      variant = specifiers.scan(/[a-z0-9]/)
+      specifiers = specifiers.scan(/[A-Z]/)
       target = target.slice(0, post)
     end
 
-	# do we need to capitalise?
-    if !(/^[A-Z]/.match(target).nil?)
+    if !(/^[A-Z]/.match(target).nil?) # do we need to capitalise?
       target = target.downcase
       up = true
     end
@@ -134,39 +201,86 @@ class JMadlibs
     mult = target.index /\+/
 
     if mult.nil? # only one list
-      return "MISSING" if @library[target].nil?
+      if @library[target].nil?
+        log "Missing wordlist: " + target, 2
+        return "MISSING"
+      end
       result = parse_pattern(@library[target].sample(random: @rng))
 
     else # more than one list
       multlist = []
       listnames = []
 
+      if false # testing new method
+
       # as long as we still have alternatives, keep adding them to listnames
-	  while !mult.nil?
+      while !mult.nil?
         listnames << target.slice(0, mult)
-		target = target.slice(mult+1, target.length - mult - 1)
+	target = target.slice(mult+1, target.length - mult - 1)
         mult = target.index /\+/
       end
-	  listnames << target # append final alternative
+      listnames << target # append final alternative
 
       # combine lists for sampling
       listnames.each do |list|
-	    if !@library[list].nil? then multlist += @library[list] end
+        if !@library[list].nil? then multlist += @library[list] end
       end
 
-	  return "MISSING" if multlist.length == 0 # no valid options found
+      if multlist.length == 0 # no valid options found
+        log "Missing wordlist: " + target, 2
+        return "MISSING"
+      end
       result = parse_pattern(multlist.sample(random: @rng))
+
+      else # Test of new routine for sampling multiple lists
+        while !mult.nil?
+          listnames << target.slice(0, mult)
+          target = target.slice(mult+1, target.length - mult - 1)
+          mult = target.index /\+/
+        end
+        listnames << target # append final alternative
+
+        # Find total count of options
+        max = 0
+
+        listnames.each do |list|
+          if !@library[list].nil? then max += @library[list].length end
+        end
+
+        # Pick index within overall size
+        index = @rng.rand(max)
+
+        # iterate through lists until we find the list the index fits into
+        listnames.each do |list|
+          if index >= @library[list].length # Not in this list, so discard its indices
+            index -= @library[list].length
+          else
+            result = parse_pattern(@library[list][index]) # in this list; return index
+            break
+          end            
+        end
+      end
     end
 
-    # do post-processing
-    if up
-      result[0] = result[0].upcase
+    # Dealing with possible variant suffixes
+
+    if result.count("\^") > 0 # if we have options...
+      if !variant.nil? and variant.length > 0 # get variant if it exists
+        variant = variant.slice!(0)
+        result = getSpecified(result, variant)
+      else # get the default
+        result = getSpecified(result)
+      end
     end
-    if specifier == "a"
+
+    # do post-processing
+
+    if specifiers.include? "A"
       result = anify(result)
     end
-    if specifier == "p"
-      result = pluralise(result)
+
+    if specifiers.include? "U"
+      result[0] = result[0].upcase
     end
 
     return result

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jmadlibs
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.8.6
 platform: ruby
 authors:
 - Gareth Morgan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-25 00:00:00.000000000 Z
+date: 2017-08-18 00:00:00.000000000 Z
 dependencies: []
 description: A madlibs engine with several powerful features
 email: jacelium@gmail.com