text-gen 0.12.5 → 0.12.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c761d6858b40d475f4514ad9f309a32fbd00bc5ca1dca0be50ecd366cc7eb965
-  data.tar.gz: c173f8bbe852bfd317f5c634fdd947a7c393089ab18e9467b5dc6a51b59c8736
+  metadata.gz: 96d238eb66df5e222ca033cbdcbc4c96a24756e9d3a24b0fedaa3f8b8c71af7f
+  data.tar.gz: 2310d7a4f9b6d290d75fefe757be1a766198bed7d5fa6835327500f7f6c11171
 SHA512:
-  metadata.gz: 8832ee6825a82219769f67ece7a73c194a4ca2e4370290a633b0b571bbb98cc754243bd7737692249b880288a13482a7d80c77e741054c6aa4a3401899416f8a
-  data.tar.gz: f78177137d036a701bf92ccae769dfdeddb6b54f9a3d18005f864dac34e25d30976683a640314b8529427de278b78dd642fe29b02749889c3cf722ee94c962e1
+  metadata.gz: 24b4e5056f75e5c862ccf4ae21638af665a7ceb0f0a1bdc739ee0ce95f856b398e61a09cc450ed3e5e2329c2c7052765dff3e7ab8daf0dd0c87f91bbe754acff
+  data.tar.gz: 4c2b802d548be347b3e674fc174648554a4627944f600a30cd9dca3e6806aa014e71952221db0f0fcd329d154151c6583afdb51d40cf05b564bbb838457a0edf

data/lib/text/gen/context.rb

@@ -64,7 +64,7 @@ module Text
 
       def remembered(key = nil)
         key ||= current_key
-        @remembered.select {|k, _r| k == key }.map(&:last)
+        @remembered.select { |k, _r| k == key }.map(&:last)
       end
 
       def remember_checkpoint

data/lib/text/gen/filter/capitalize.rb

@@ -3,6 +3,8 @@
 module Text
   module Gen
     module Filter
+      # Capitalize the result text; first character only by default.
+      # Use `capitalize:force` to use the default ruby `capitalize` method
       class Capitalize < Base
         def result(context, result)
           return result if @depth && context.depth != @depth

data/lib/text/gen/filter/censor.rb

@@ -3,9 +3,12 @@
 module Text
   module Gen
     module Filter
+      # Censor looks up a different builder and rejects the result if
+      # the result text is included in the
       class Censor < Base
         def result(context, result)
           return result if @depth && context.depth != @depth
+
           return result if key.nil?
 
           builder = context.store.fetch(key)

data/lib/text/gen/filter/clear.rb

@@ -3,7 +3,7 @@
 module Text
   module Gen
     module Filter
-      # Clears result meta
+      # Clear removes result meta
       class Clear < Base
         def result(context, result)
           return result if @depth && context.depth != @depth

data/lib/text/gen/filter/distinct.rb

@@ -9,7 +9,7 @@ module Text
           return result if key != context.current_key
 
           previous = context.remembered(key)
-          return nil if previous.any? { |r| r.text.strip.downcase == result.text.strip.downcase }
+          return if previous.any? { |r| r.text.strip.downcase == result.text.strip.downcase }
 
           result
         end

data/lib/text/gen/filter/downcase.rb

@@ -3,6 +3,7 @@
 module Text
   module Gen
     module Filter
+      # Downcase returns the result text using the default lowercase rules
       class Downcase < Base
         def result(context, result)
           return result if @depth && context.depth != @depth

data/lib/text/gen/filter/exclude.rb

@@ -3,13 +3,15 @@
 module Text
   module Gen
     module Filter
+      # Exclude is the opposite of `match` and returns nil if
+      # the result metadata is matches the pattern in this filter.
       class Exclude < Base
         def result(context, result)
           return result if @depth && context.depth != @depth
-          return nil if result.nil?
-          return nil if value == "*" && result.meta.key?(key)
-          return nil if key == "*" && result.meta.values.any? { |arr| arr.include?(value) }
-          return nil if result.meta[key]&.include?(value)
+          return if result.nil?
+          return if value == "*" && result.meta.key?(key)
+          return if key == "*" && result.meta.values.any? { |arr| arr.include?(value) }
+          return if result.meta[key]&.include?(value)
 
           result
         end

data/lib/text/gen/filter/match.rb

@@ -3,6 +3,8 @@
 module Text
   module Gen
     module Filter
+      # Match returns `nil` unless the result metadata includes
+      # the given pattern.
       class Match < Base
         def result(context, result)
           return result if @depth && context.depth != @depth

data/lib/text/gen/filter/meta.rb

@@ -3,6 +3,7 @@
 module Text
   module Gen
     module Filter
+      # Meta adds meta tags to the result
       class Meta < Base
         def result(context, result)
           return result if @depth && context.depth != @depth

data/lib/text/gen/filter/pluralize.rb

@@ -30,7 +30,13 @@ module Text
           return result if @depth && context.depth != @depth
 
           text = result.text
-          text = pluralize(text, result.multiplier)
+          text = if key && value
+                   substitute(text, result.multiplier)
+                 elsif key
+                   pluralize_by_key(text, result.multiplier, result)
+                 else
+                   pluralize(text, result.multiplier)
+                 end
           return result if text == result.text
 
           Result.from(result, text:, type: component_key)
@@ -38,27 +44,74 @@ module Text
 
         private
 
+        # Splits a string into alternating word and non-word tokens, preserving all characters.
+        # e.g. "5 swords." => ["5", " ", "swords", "."]
+        def tokenize(str)
+          str.scan(/\w+|\W+/)
+        end
+
+        def pluralize_by_key(str, multiplier, result)
+          tokens = tokenize(str)
+          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          idx = word_tokens.rindex { |s| to_num(s) }
+          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
+          return str if num.nil? || num <= 1
+
+          component = find_component(result, key)
+          return str unless component
+
+          component_text = component.text
+          return str if component_text.nil? || component_text.strip.empty?
+
+          component_tokens = tokenize(component_text)
+          last_word_idx = component_tokens.rindex { |t| t.match?(/\w/) }
+          return str unless last_word_idx
+
+          dc = component_tokens[last_word_idx].downcase
+          component_tokens[last_word_idx] = exceptions(dc) || single_letter(dc) || others(dc) || ends_with_y(dc) || simple(dc)
+          str.sub(component_text, component_tokens.join)
+        end
+
+        def find_component(result, search_key)
+          return result if result.type == search_key
+
+          result.components.each do |c|
+            found = find_component(c, search_key)
+            return found if found
+          end
+          nil
+        end
+
+        def substitute(str, multiplier = 1)
+          tokens = tokenize(str)
+          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          idx = word_tokens.rindex { |s| to_num(s) }
+          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
+          return str if num.nil? || num <= 1
+
+          tokens.map! { |t| t.match?(/\A#{Regexp.escape(key)}\z/i) ? value : t }
+          tokens.join
+        end
+
         def pluralize(str, multiplier = 1)
           return str if str.empty?
 
-          arr = str.split(/\s+/)
-          return str if arr.length < 2
+          tokens = tokenize(str)
+          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          return str if word_tokens.length < 2
 
-          idx = arr.rindex { |s| to_num(s) }
+          idx = word_tokens.rindex { |s| to_num(s) }
 
           # Use the multiplier if available, otherwise parse from text
-          num = if multiplier > 1
-                  multiplier
-                else
-                  (idx ? to_num(arr[idx]) : nil)
-                end
+          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
 
           return str if num.nil? || num <= 1
-          return str if idx && idx >= arr.length - 1
+          return str if idx && idx >= word_tokens.length - 1
 
-          dc = arr[-1].downcase
-          arr[-1] = exceptions(dc) || single_letter(dc) || others(dc) || ends_with_y(dc) || simple(dc)
-          arr.join(" ")
+          last_word_idx = tokens.rindex { |t| t.match?(/\w/) }
+          dc = tokens[last_word_idx].downcase
+          tokens[last_word_idx] = exceptions(dc) || single_letter(dc) || others(dc) || ends_with_y(dc) || simple(dc)
+          tokens.join
         end
 
         def to_num(str)

data/lib/text/gen/filter/reject.rb

@@ -3,6 +3,8 @@
 module Text
   module Gen
     module Filter
+      # Reject reduces the items in the array to **only** those without
+      # the given metadata. This is the opposite of `select`.
       class Reject < Base
         def items(_context, items)
           items.select do |item|

data/lib/text/gen/filter/select.rb

@@ -3,8 +3,11 @@
 module Text
   module Gen
     module Filter
+      # Select reduces the items in the array to **only** those with passing
+      # metadata. This happens before generation as opposed to `match` which
+      # applies a pass/fail to the result.
       class Select < Base
-        def apply(items)
+        def items(_context, items)
           items.select do |item|
             pass_select?(item["meta"])
           end

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.12.5"
+    VERSION = "0.12.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.12.6
 platform: ruby
 authors:
 - G Palmer