text-gen 0.12.5 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c761d6858b40d475f4514ad9f309a32fbd00bc5ca1dca0be50ecd366cc7eb965
-  data.tar.gz: c173f8bbe852bfd317f5c634fdd947a7c393089ab18e9467b5dc6a51b59c8736
+  metadata.gz: 2afbd1cd20f4be4fa1c6ebb125fda4894f46026a078b8b54f808ed1e9fb684e6
+  data.tar.gz: '043274280f1ff52837206196ee489932b64c85f1a2af037b9b29cf1127ae1236'
 SHA512:
-  metadata.gz: 8832ee6825a82219769f67ece7a73c194a4ca2e4370290a633b0b571bbb98cc754243bd7737692249b880288a13482a7d80c77e741054c6aa4a3401899416f8a
-  data.tar.gz: f78177137d036a701bf92ccae769dfdeddb6b54f9a3d18005f864dac34e25d30976683a640314b8529427de278b78dd642fe29b02749889c3cf722ee94c962e1
+  metadata.gz: cce97e373664b52db5752f18d0a672041246486fdd4848aeb74febf96f099543ac04ac97c5609ea71877ac867afa9a805a51862d5099ddad3dc74be81f9579ea
+  data.tar.gz: 5762c3a92aca626f66e5127ab9aef91bc7a14bce1111e44836f7b083b7cc35ee387b4f8f5f0ea4351d38fad789a3bdde015dfce7f81257f78740f5627870f8c6

data/CHANGELOG.md

@@ -1,4 +1,7 @@
-## [Unreleased]
+## [0.13.0] - 2026-06-20 
+
+- Builder items can be concatonated by using the `+` operator (e.g. `key1+key2`)
+- Cleaned up the strategy behavior to default to "weigted" and renamed "random" to "sample"  
 
 ## [0.1.0] - 2025-12-28
 

data/lib/text/gen/context.rb

@@ -4,6 +4,8 @@ module Text
   module Gen
     # Keep the context for one run.
     class Context
+      KNOWN_STRATEGIES = Set.new(%w[random weighted sequence sample])
+
       attr_reader :store, :depth
 
       def initialize(store:, filters: nil, meta: nil, max_recursion: 10)
@@ -22,10 +24,19 @@ module Text
       def descend!(builder)
         @depth += 1
         @keys << builder["key"]
-        @strategy_stack << (builder["strategy"] || "random").split(":", 2)
+        @strategy_stack << strategy_to_stack_item(builder)
         raise MaxRecursionError if @depth > @max_recursion
       end
 
+      def strategy_to_stack_item(builder)
+        strategy, modifier = builder.fetch("strategy", "weighted").split(":", 2)
+        unless KNOWN_STRATEGIES.include?(strategy)
+          modifier = strategy
+          strategy = "weighted"
+        end
+        [strategy, modifier]
+      end
+
       def ascend!
         @depth -= 1
         @keys.pop
@@ -50,7 +61,7 @@ module Text
       end
 
       def current_strategy
-        @strategy_stack.last&.first || "random"
+        @strategy_stack.last&.first || "weighted"
       end
 
       def current_modifier
@@ -64,7 +75,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/runner.rb

@@ -68,12 +68,12 @@ module Text
         return if items.empty?
 
         case context.current_strategy
+        when "sample"
+          run_random_item(context, items)
         when "sequence"
           run_item_sequence(context, items)
-        when "weighted"
-          run_weighted_items(context, items)
         else
-          run_random_item(context, items)
+          run_weighted_items(context, items)
         end
       end
 
@@ -94,7 +94,7 @@ module Text
       end
 
       def run_weighted_items(context, items)
-        total_weight = items.sum { |item| [item.fetch("weight", 1).to_i, 1].max }
+        total_weight = calculate_total_weight(context, items)
         dice = context.current_modifier
         rand_weight = if dice.nil? || dice.empty? || dice == "*"
                         rand(total_weight)
@@ -104,6 +104,7 @@ module Text
                       end
         return if rand_weight > total_weight
 
+
         current_weight = 0
         item = items.find do |item|
           current_weight += [item.fetch("weight", 1).to_i, 1].max
@@ -201,6 +202,36 @@ module Text
         end
       end
 
+      def calculate_weight(context, item)
+        weight = item["weight"]
+        if weight == "*"
+          reference = item["segments"]&.find { |s| s["type"] == "reference" }
+          key = reference&.fetch("text")
+          weight = lookup_and_count_items(context, key)
+        end
+
+        weight.to_i < 1 ? 1 : weight.to_i
+      end
+
+      def lookup_and_count_items(context, key)
+        return 0 unless key
+
+        builder = context.store.fetch(key)
+        return 0 unless builder
+
+        builder["items"]&.size || 1
+      end
+
+      def calculate_total_weight(context, items)
+        sum = 0
+        items.each do |item|
+          weight = calculate_weight(context, item)
+          item["weight"] = weight
+          sum += weight
+        end
+        sum
+      end
+
       def random_from_dice(text)
         rolled = DiceNomShim.roll(text)
         parsed = JSON.parse(rolled).first["lhs"]

data/lib/text/gen/store.rb

@@ -6,6 +6,7 @@ module Text
     # to save time on database lookups or transformations.
     class Store
       NOT_FOUND_BUILDER = {
+        "strategy" => "sample",
         "filters" => [],
         "meta" => {},
         "items" => []
@@ -33,12 +34,30 @@ module Text
         builder = find(key)
         return builder if builder
 
-        builder = @lookup.call(key)
-        return not_found(key) unless builder
+        keys = key.split("+")
+        builders = keys.map do |key|
+          builder = @lookup.call(key)
+          builder = not_found(key) unless builder
+          builder
+        end
 
+        builder = merge_builders(builders) if builders.length > 1
         add(key, builder.merge("key" => key.to_s.downcase))
       end
 
+      def merge_builders(builders)
+        all_filters = builders.map { |b| b["filters"] }.flatten
+        all_meta = builders.inject({}) { |b, acc| acc = Text::Gen::Meta.merge_meta(acc, b["meta"]) }
+        all_items = builders.map { |b| b["items"] }.flatten
+        strategy = builders.all? {|b| b["strategy"] == "weighted" } ? "weighted" : "sample"
+        {
+          "strategy" => strategy,
+          "filters" => all_filters,
+          "meta" => all_meta,
+          "items" => all_items,
+        }
+      end
+
       def not_found(key)
         hsh = NOT_FOUND_BUILDER.dup
         hsh["key"] = key

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.12.5"
+    VERSION = "0.13.0"
   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.13.0
 platform: ruby
 authors:
 - G Palmer