text-gen 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e428f6d3e941577501a173778ed8630413aaf73557d48692da86def7a8daa814
-  data.tar.gz: 98f0050634808ed37898ae14de3becbd279b59c842b9231929c6008b25e13083
+  metadata.gz: ae82c6d0373286c09c677ea3c29fa7eb910884c130c8733251fa324b2f02b55e
+  data.tar.gz: d7c8715bb09f18bf47169964ddb1e9c3a050dd5535fe1ae615f3ef82258755ca
 SHA512:
-  metadata.gz: dcf076afcb96bdcd66b653bce9d59123f3d0dae3f098c8f4b9156d66092168961fa1a5c1e03300eaf3aac595b3b41cabc3e2e1011a4d39e72aff437aa50fac1a
-  data.tar.gz: 65728334bcc7b08f7135a690626ca64d8bf5870b25f20ed954b260d4024c017213f09aee29a7e9d4474a1a1c3305a726005349561ed46271c9b6e81bf9bdf65c
+  metadata.gz: 6430058076ee97e12004401ee935646f7ac2f3443e852b730a3b541c609691344fa15490306c69ef42ed932dd2e8efc40a7542d34bcc4bc7b2b65751700211cb
+  data.tar.gz: a985c9ebcb2f08492e7dcf7eb42c5f18766d9c4fc406f65bece512870a94f0e674bb14fb6212ca4ba56761f87a74af705a5248b8da10eaecaae8b82550019e0b

data/lib/text/gen/filter.rb

@@ -25,8 +25,6 @@ require_relative "filter/item/reject"
 module Text
   module Gen
     module Filter
-      SEPARATORS = { "tab" => "\t", "newline" => "\n", "space" => " " }.freeze
-
       RESULT_FILTER_CLASSES = {
         "capitalize" => Filter::Result::Capitalize,
         "censor" => Filter::Result::Censor,
@@ -139,16 +137,6 @@ module Text
           citem
         end
 
-        def separator(filters)
-          return "" unless filters
-
-          separator_filter = filter_by_type(filters, "separator")
-          return "" unless separator_filter
-          return separator_filter["value"] if separator_filter["key"] == "string"
-
-          SEPARATORS.fetch(separator_filter["key"], "")
-        end
-
         def filter_by_type(filters, type)
           filters&.find { |f| f["type"] == type }
         end

data/lib/text/gen/result.rb

@@ -5,6 +5,8 @@ module Text
     # Result stores the generated text, value and metadata and context about
     # how it was created
     class Result
+      SEPARATORS = { "tab" => "\t", "newline" => "\n", "space" => " " }.freeze
+
       attr_reader :text, :type, :value, :multiplier, :meta, :components
 
       def initialize(text:, type:, value: 0, multiplier: 1)
@@ -73,11 +75,11 @@ module Text
           end
         end
 
-        def merge(results, value: nil, multiplier: nil, filters: [], meta: {}, type: :sequence)
+        def merge(results, value: nil, multiplier: nil, separator: "", meta: {}, type: :sequence)
           results = results.compact
-          sep = Filter.separator(filters)
           mul = multiplier || results.reduce(1) { |acc, r| acc * r.multiplier }
           val = value || results.sum(&:value)
+          sep = SEPARATORS[separator] || separator
           new(
             text: results.map(&:text).join(sep),
             type: type,

data/lib/text/gen/runner.rb

@@ -25,8 +25,6 @@ module Text
         @unique
       end
 
-      # A filter of type "replace:key:value" creates a temporary builder
-      # that always returns the given value.
       def populate_replace
         @request_filters.each do |f|
           store.add(f["key"], Filter.constant_builder(f["key"], f["value"])) if f["type"] == "replace"
@@ -85,7 +83,7 @@ module Text
 
         current_filters = merge_filters(builder, filters)
         current_items = apply_item_filters(builder["items"], current_filters)
-        result = run_items(key, builder["strategy"], current_items, current_filters, builder["meta"], depth)
+        result = run_items(key, builder, current_items, current_filters, builder["meta"], depth)
         return unless result
 
         result.merge_meta(builder["meta"])
@@ -97,31 +95,32 @@ module Text
         Result.new(text:, type: :error)
       end
 
-      def run_items(key, strategy, items, filters, meta, depth)
+      def run_items(key, builder, items, filters, meta, depth)
+        strategy, modifier = (builder["strategy"] || "random").split(":")
         case strategy
         when "sequence"
-          run_item_sequence(key, items, filters, meta, depth)
+          run_item_sequence(key, modifier, items, filters, meta, depth)
         when "weighted"
-          run_weighted_items(key, items, meta, depth)
+          run_weighted_items(key, modifier, items, meta, depth)
         else
-          run_random_item(key, strategy, items, meta, depth)
+          run_random_item(key, modifier, items, meta, depth)
         end
       rescue StandardError => e
         error_result("{#{e.class.name}:#{e.message}}")
       end
 
-      def random_item(strategy, items)
-        return items.sample if strategy.nil? || strategy.empty? || strategy == "random"
+      def random_item(dice, items)
+        return items.sample if dice.nil? || dice.empty? || dice == "*"
 
-        total, count = random_from_dice(strategy)
+        total, count = random_from_dice(dice)
         index = total - count # convert to 0-indexed
         raise NoItemMatched("roll #{total} exceeds #{items.length}") if index >= items.length
 
         items[index]
       end
 
-      def run_random_item(key, strategy, items, meta, depth)
-        item = random_item(strategy, items)
+      def run_random_item(key, dice, items, meta, depth)
+        item = random_item(dice, items)
         result = run_item(key, item, depth)
         return unless result
 
@@ -129,16 +128,30 @@ module Text
         result
       end
 
-      def run_item_sequence(key, items, filters, meta, depth)
-        results = items.map { |item| run_item(key, item, depth) }.compact
+      def run_item_sequence(key, separator, items, filters, meta, depth)
+        results = items.map do |item|
+          weight = item["weight"]&.to_i || 100
+          next unless rand(100) < weight.clamp(1, 100)
+
+          run_item(key, item, depth)
+        end
+
+        results = results.compact
         return if results.empty?
 
-        Result.merge(results, filters:, meta:, type: :sequence)
+        Result.merge(results, separator: separator || "", meta:, type: :sequence)
       end
 
-      def run_weighted_items(key, items, meta, depth)
+      def run_weighted_items(key, dice, items, meta, depth)
         total_weight = items.sum { |item| [item.fetch("weight", 1).to_i, 1].max }
-        rand_weight = rand(total_weight)
+        rand_weight = if dice.nil? || dice.empty? || dice == "*"
+          rand(total_weight)
+        else
+          total, count = random_from_dice(dice)
+          total - count # convert to 0-indexed
+        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
@@ -156,7 +169,6 @@ module Text
         result = Result.merge(results,
                               value: item["value"],
                               multiplier: item["multiplier"],
-                              filters: item["filters"],
                               meta: item["meta"],
                               type: key)
         result = apply_result_function(result, item["filters"])
@@ -179,7 +191,9 @@ module Text
       def random_from_dice(text)
         rolled = DiceNomShim.roll(text)
         parsed = JSON.parse(rolled).first["lhs"]
-        count = parsed["values"].size
+
+        # Keep tracks the dice that weren't discarded
+        count = parsed["values"].select {|v| v["keep"] }.count
         total = parsed["total"]
         [total, count]
       end

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.10.1"
+    VERSION = "0.11.0"
   end
 end

metadata

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