text-gen 0.12.6 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96d238eb66df5e222ca033cbdcbc4c96a24756e9d3a24b0fedaa3f8b8c71af7f
-  data.tar.gz: 2310d7a4f9b6d290d75fefe757be1a766198bed7d5fa6835327500f7f6c11171
+  metadata.gz: 5581ccb42efa3604510e17f8af69e6d5b804cc60702f6e1f7001cebf8def8c54
+  data.tar.gz: 840ffc9473992cb64850991e4ee442c774acee38ddbdf40e81257be9c69b756d
 SHA512:
-  metadata.gz: 24b4e5056f75e5c862ccf4ae21638af665a7ceb0f0a1bdc739ee0ce95f856b398e61a09cc450ed3e5e2329c2c7052765dff3e7ab8daf0dd0c87f91bbe754acff
-  data.tar.gz: 4c2b802d548be347b3e674fc174648554a4627944f600a30cd9dca3e6806aa014e71952221db0f0fcd329d154151c6583afdb51d40cf05b564bbb838457a0edf
+  metadata.gz: 511f34f2a2a29d8c50a85d8b63f504b420047db4e219783525ab855ccd41582b6e9673b3f02bcbb5c2ea1ed9fdf515160a5a6e3b18b251686f55cf0ee3cb10fd
+  data.tar.gz: 1b74d7812ff49c5026afd623630435921b7f366c754388439e628a00e0766919458cebf6a22f93bd914f307d8016138b1bcab15104cb01bac3cc132c454d5eb5

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

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

@@ -12,7 +12,7 @@ module Text
         end
 
         def component_key
-          "fn(#{to_s})"
+          "fn(#{self})"
         end
 
         # Shared utilities
@@ -33,8 +33,9 @@ module Text
         end
 
         def to_s
-          return "#{ type }:#{ key }:#{ value }" if value
-          return "#{ type }:#{ key }" if key
+          return "#{type}:#{key}:#{value}" if value
+          return "#{type}:#{key}" if key
+
           type
         end
 

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

@@ -52,9 +52,13 @@ module Text
 
         def pluralize_by_key(str, multiplier, result)
           tokens = tokenize(str)
-          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          word_tokens = tokens.grep(/\w/)
           idx = word_tokens.rindex { |s| to_num(s) }
-          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
+          num = if multiplier > 1
+                  multiplier
+                else
+                  (idx ? to_num(word_tokens[idx]) : nil)
+                end
           return str if num.nil? || num <= 1
 
           component = find_component(result, key)
@@ -68,7 +72,8 @@ module Text
           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)
+          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
 
@@ -84,9 +89,13 @@ module Text
 
         def substitute(str, multiplier = 1)
           tokens = tokenize(str)
-          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          word_tokens = tokens.grep(/\w/)
           idx = word_tokens.rindex { |s| to_num(s) }
-          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
+          num = if multiplier > 1
+                  multiplier
+                else
+                  (idx ? to_num(word_tokens[idx]) : nil)
+                end
           return str if num.nil? || num <= 1
 
           tokens.map! { |t| t.match?(/\A#{Regexp.escape(key)}\z/i) ? value : t }
@@ -97,13 +106,17 @@ module Text
           return str if str.empty?
 
           tokens = tokenize(str)
-          word_tokens = tokens.select { |t| t.match?(/\w/) }
+          word_tokens = tokens.grep(/\w/)
           return str if word_tokens.length < 2
 
           idx = word_tokens.rindex { |s| to_num(s) }
 
           # Use the multiplier if available, otherwise parse from text
-          num = multiplier > 1 ? multiplier : (idx ? to_num(word_tokens[idx]) : nil)
+          num = if multiplier > 1
+                  multiplier
+                else
+                  (idx ? to_num(word_tokens[idx]) : nil)
+                end
 
           return str if num.nil? || num <= 1
           return str if idx && idx >= word_tokens.length - 1

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

@@ -4,7 +4,7 @@ module Text
   module Gen
     module Filter
       class Replace < Base
-        def builder(context, builder)
+        def builder(_context, builder)
           return builder unless builder["key"] == key
 
           Result.new(text: value, type: "replace")

data/lib/text/gen/filter.rb

@@ -14,7 +14,7 @@ module Text
         def build(hsh_or_key, depth)
           hsh = hsh_or_key.is_a?(Hash) ? hsh_or_key : key_to_hsh(hsh_or_key)
           filter_class = available_filters.find { |f| f.filter_key == hsh["type"] }
-          filter_class.new(hsh, depth) if filter_class
+          filter_class&.new(hsh, depth)
         end
 
         def key_to_hsh(key)

data/lib/text/gen/meta.rb

@@ -33,7 +33,7 @@ module Text
           else
             hsh.each_key do |k|
               if hsh.key?(k)
-                new_hsh[k] = k == key ? hsh[k].select { |v| v != val } : hsh[k].dup
+                new_hsh[k] = k == key ? hsh[k].reject { |v| v == val } : hsh[k].dup
               end
             end
           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)
@@ -142,10 +142,10 @@ module Text
           return if results.any?(&:nil?) || results.empty?
 
           result = Result.merge(results,
-                       value: item["value"],
-                       multiplier: item["multiplier"],
-                       meta: item["meta"],
-                       type: context.current_key)
+                                value: item["value"],
+                                multiplier: item["multiplier"],
+                                meta: item["meta"],
+                                type: context.current_key)
           context.apply_result_filters(result)
         end
       end
@@ -201,6 +201,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].max
+      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/segment/reference.rb

@@ -4,7 +4,7 @@ module Text
   module Gen
     module Segment
       class Reference
-        REFERENCE_MATCHER = /\[\s*([a-z0-9-]+(?::[a-z0-9-]+)*)\s*\]/
+        REFERENCE_MATCHER = /\[\s*([a-z0-9-]+(?:(?:>>|>|:)[a-z0-9-]+)*)\s*\]/
         class << self
           def scan(scanner)
             str = scanner.scan(REFERENCE_MATCHER)

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)
+          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| 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.6"
+    VERSION = "0.13.2"
   end
 end

metadata

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