text-gen 0.11.3 → 0.12.0

data/lib/text/gen/runner.rb

@@ -7,149 +7,90 @@ module Text
   module Gen
     # Runner generates results from the builder that is found with the given key.
     class Runner
-      attr_reader :key, :lookup, :max_attempts, :max_recursion
-      attr_accessor :unique, :store
+      attr_reader :key, :lookup, :max_attempts, :max_recursion, :filters, :meta
 
-      def initialize(key:, lookup:, max_recursion: 10, max_attempts: 10, request_filters: [])
+      def initialize(key:, lookup:, max_recursion: 10, max_attempts: 10, filters: [], meta: {})
         @key = key.to_s.downcase
         @lookup = lookup
-        @store = Store.new
-        @unique = false
-        @request_filters = request_filters
+        @filters = filters
+        @meta = meta
         @max_attempts = max_attempts
         @max_recursion = max_recursion
-        populate_replace
-      end
-
-      def unique?
-        @unique
-      end
-
-      def populate_replace
-        @request_filters.each do |f|
-          store.add(f["key"], Filter.constant_builder(f["key"], f["value"])) if f["type"] == "replace"
-        end
       end
 
       def run(count: 1)
-        builder = fetch_builder(key)
-        return Array.new(count, error_result("{builder `#{key}` not found}")) unless builder
+        store = Store.new(lookup)
+        builder = store.fetch(key)
+        raise NoBuilderMatched, "{builder `#{key}` not found}" unless builder
 
-        ResultAccumulator.accumulate(unique: unique?, count: count, max_attempts: max_attempts) do
-          run_builder(key, builder, @request_filters, 0)
+        context = Context.new(store:, filters:, meta:, max_recursion:)
+        ResultAccumulator.accumulate(count:, max_attempts:) do
+          run_builder(context, builder)
         end
       end
 
-      def investigate
-        visit_and_recurse(key, 0).sort.uniq
-      end
+      # A builder is hash with a key field, items, filters, and meta
+      def run_builder(context, builder)
+        context.descend!(builder)
+        context.with_filters(builder["filters"]) do
+          builder = context.apply_builder_filters(builder)
+          return unless builder
 
-      # Returns a hash of all available filters with their parameters.
-      # Filters requiring explicit parameters will have an array of parameter names.
-      # Filters without parameters will have an empty array.
-      def available_filters
-        Filter.available_filters
-      end
+          # Filter mapping of builder to result is allowed
+          return builder if builder.is_a?(Result)
 
-      def visit_and_recurse(key, depth)
-        depth += 1
-        raise MaxRecursionError if depth > max_recursion
-
-        builder = fetch_builder(key)
-        keys = [key]
-        builder["items"].each do |item|
-          item["segments"].each do |segment|
-            if segment["type"] == "reference"
-              keys << segment["text"]
-              keys += visit_and_recurse(segment["text"], depth)
-            end
-          end
-        end
-        keys
-      rescue => e
-        [key]
-      end
+          result = builder.is_a?(Result) ? builder : run_items(context, builder["items"])
+          return unless result
 
-      def fetch_builder(key)
-        builder = @store.find(key) || lookup.call(key)
-        @store.add(key, builder)
-        builder
-      end
+          result.merge_meta(builder["meta"])
+          result = context.apply_result_filters(result)
+          return unless result
 
-      # A builder is hash with a key field, items, filters, and meta
-      def run_builder(key, builder, filters, depth)
-        depth += 1
-        raise MaxRecursionError if depth > max_recursion
-
-        current_filters = merge_filters(builder, filters)
-        current_items = apply_item_filters(builder["items"], current_filters)
-        result = run_items(key, builder, current_items, current_filters, builder["meta"], depth)
-        return unless result
-
-        result.merge_meta(builder["meta"])
-        result = apply_result_function(result, current_filters)
-        apply_result_filters(result, current_filters)
+          context.remember(result)
+        end
+      ensure
+        context.ascend!
       end
 
-      def error_result(text = "{error}")
-        Result.new(text:, type: :error)
-      end
+      def run_items(context, items)
+        items = context.apply_item_list_filters(items)
+        return if items.empty?
 
-      def run_items(key, builder, items, filters, meta, depth)
-        strategy, modifier = (builder["strategy"] || "random").split(":")
-        case strategy
+        case context.current_strategy
         when "sequence"
-          run_item_sequence(key, modifier, items, filters, meta, depth)
+          run_item_sequence(context, items)
         when "weighted"
-          run_weighted_items(key, modifier, items, meta, depth)
+          run_weighted_items(context, items)
         else
-          run_random_item(key, modifier, items, meta, depth)
+          run_random_item(context, items)
         end
-      rescue StandardError => e
-        error_result("{#{e.class.name}:#{e.message}}")
       end
 
-      def random_item(dice, items)
-        return items.sample if dice.nil? || dice.empty? || dice == "*"
-
-        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, dice, items, meta, depth)
-        item = random_item(dice, items)
-        result = run_item(key, item, depth)
-        return unless result
-
-        result.merge_meta(meta)
-        result
-      end
-
-      def run_item_sequence(key, separator, items, filters, meta, depth)
+      def run_item_sequence(context, items)
         results = items.map do |item|
           weight = item["weight"]&.to_i || 100
           next unless rand(100) < weight.clamp(1, 100)
 
-          run_item(key, item, depth)
+          ResultAccumulator.accumulate(count: 1, max_attempts: @max_attempts) do
+            run_item(context, item)
+          end.first
         end
 
         results = results.compact
         return if results.empty?
 
-        Result.merge(results, separator: separator || "", meta:, type: :sequence)
+        Result.merge(results, separator: context.current_modifier, type: :sequence)
       end
 
-      def run_weighted_items(key, dice, items, meta, depth)
+      def run_weighted_items(context, items)
         total_weight = items.sum { |item| [item.fetch("weight", 1).to_i, 1].max }
+        dice = context.current_modifier
         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
+                        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
@@ -157,47 +98,75 @@ module Text
           current_weight += [item.fetch("weight", 1).to_i, 1].max
           current_weight > rand_weight
         end
-        result = run_item(key, item, depth)
-        return unless result
 
-        result.merge_meta(meta)
-        result
+        run_item(context, item)
+      end
+
+      def run_random_item(context, items)
+        item = random_item(items, dice: context.current_modifier)
+        return unless item
+
+        run_item(context, item)
+      end
+
+      def random_item(items, dice: nil)
+        return items.sample if dice.nil? || dice.empty? || dice == "*"
+
+        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_item(context, item)
+        item = context.apply_item_filters(item)
+        return unless item
+
+        # Filter mapping of item to result is allowed
+        return item if item.is_a?(Result)
+
+        context.with_filters(item["filters"]) do
+          results = item["segments"].map { |seg| run_segment(context, seg) }.compact
+          return if results.empty?
+
+          Result.merge(results,
+                       value: item["value"],
+                       multiplier: item["multiplier"],
+                       meta: item["meta"],
+                       type: context.current_key)
+        end
       end
 
-      def run_item(key, item, depth)
-        results = item["segments"].map { |seg| run_segment(seg, depth) }
-        result = Result.merge(results,
-                              value: item["value"],
-                              multiplier: item["multiplier"],
-                              meta: item["meta"],
-                              type: key)
-        result = apply_result_function(result, item["filters"])
-        apply_result_filters(result, item["filters"])
+      def run_segment(context, seg)
+        # Note, a filter may expand a segment into multiple segments
+        segments = context.apply_segment_filters(seg)
+        return if segments.nil?
+
+        # Filter mapping of segment to result is allowed
+        return segments if segments.is_a?(Result)
+
+        results = segments.map { |seg| run_simple_segment(context, seg) }.compact
+        return if results.empty?
+
+        return results[0] if results.length == 1
+
+        Result.merge(results, type: "segment expansion")
       end
 
-      def run_segment(seg, depth)
+      def run_simple_segment(context, seg)
         case seg["type"]
         when "dice"
           run_dice_segment(seg)
         when "number"
           run_number_segment(seg)
         when "reference"
-          run_reference_segment(seg, depth)
+          run_reference_segment(context, seg)
         else
           Result.new(text: seg["text"], value: seg["value"], type: :constant)
         end
       end
 
-      def random_from_dice(text)
-        rolled = DiceNomShim.roll(text)
-        parsed = JSON.parse(rolled).first["lhs"]
-
-        # Keep tracks the dice that weren't discarded
-        count = parsed["values"].select {|v| v["keep"] }.count
-        total = parsed["total"]
-        [total, count]
-      end
-
       def run_dice_segment(seg)
         total, = random_from_dice(seg["text"])
         Result.new(text: total.to_s, multiplier: total, type: :dice)
@@ -208,56 +177,26 @@ module Text
         Result.new(text: num.to_s, multiplier: num, type: :number)
       end
 
-      def run_reference_segment(seg, depth)
+      def run_reference_segment(context, seg)
         key = seg["text"]
-        run_builder(key, fetch_builder(key), seg.fetch("filters", []), depth)
-      end
-
-      def apply_result_filters(result, filters)
-        result = Filter.result_select(result, filters)
-        result = Filter.result_reject(result, filters) if result
-        result
-      end
-
-      def apply_result_function(result, filters)
-        Filter.functions(result, filters, lookup: lookup)
-      end
-
-      def merge_filters(builder, filters)
-        builder.key?("filters") ? builder["filters"] + filters : filters
-      end
 
-      def apply_item_filters(items, filters)
-        items = Filter.filter_locale(items, @request_filters + filters)
-        items = Filter.filter_select(items, filters)
-        items = Filter.filter_reject(items, filters)
-        raise FilterError if items.empty?
-
-        items
-      end
+        builder = context.store.fetch(key)
+        return unless builder
 
-      def to_h
-        {
-          "key" => key,
-          "request_filters" => request_filters,
-          "request_meta" => request_meta,
-          "store" => store.to_h
-        }
+        # Offset by one to ensure the segment filters are applied to the builder
+        context.with_filters(seg["filters"], offset: 1) do
+          run_builder(context, builder)
+        end
       end
 
-      class << self
-        def from_hash(hash)
-          runner = Runner.new(
-            key: hash["key"],
-            request_filters: hash.fetch("request_filters", [])
-          )
-
-          hash.fetch("store", {}).each do |k, b|
-            runner.store.add(k, b)
-          end
+      def random_from_dice(text)
+        rolled = DiceNomShim.roll(text)
+        parsed = JSON.parse(rolled).first["lhs"]
 
-          runner
-        end
+        # Keep tracks the dice that weren't discarded
+        count = parsed["values"].select { |v| v["keep"] }.count
+        total = parsed["total"]
+        [total, count]
       end
     end
   end

data/lib/text/gen/store.rb

@@ -5,7 +5,14 @@ module Text
     # Store is a local cache of a builder that is persistent per store
     # to save time on database lookups or transformations.
     class Store
-      def initialize
+      NOT_FOUND_BUILDER = {
+        "filters" => [],
+        "meta" => {},
+        "items" => []
+      }.freeze
+
+      def initialize(lookup)
+        @lookup = lookup
         @store = {}
       end
 
@@ -15,6 +22,27 @@ module Text
 
       def add(key, builder)
         @store[key.to_s.downcase] = builder
+        builder
+      end
+
+      def clear(key)
+        @store.delete(key.to_s.downcase)
+      end
+
+      def fetch(key)
+        builder = find(key)
+        return builder if builder
+
+        builder = @lookup.call(key)
+        return not_found(key) unless builder
+
+        add(key, builder.merge("key" => key.to_s.downcase))
+      end
+
+      def not_found(key)
+        hsh = NOT_FOUND_BUILDER.dup
+        hsh["key"] = key
+        hsh
       end
 
       def to_h

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.11.3"
+    VERSION = "0.12.0"
   end
 end

data/lib/text/gen.rb

@@ -6,13 +6,17 @@ require_relative "gen/result_accumulator"
 require_relative "gen/result"
 require_relative "gen/segment/parser"
 require_relative "gen/filter"
+require_relative "gen/context"
+require_relative "gen/meta"
 require_relative "gen/store"
 require_relative "gen/runner"
+require_relative "gen/investigator"
 
 module Text
   module Gen
     class MaxRecursionError < StandardError; end
     class MaxAttemptsError < StandardError; end
+    class NoBuilderMatched < StandardError; end
     class NoItemMatched < StandardError; end
     class FilterError < StandardError; end
     class LookupError < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.11.3
+  version: 0.12.0
 platform: ruby
 authors:
 - G Palmer
@@ -41,24 +41,28 @@ files:
 - README.md
 - Rakefile
 - lib/text/gen.rb
+- lib/text/gen/context.rb
 - lib/text/gen/filter.rb
 - lib/text/gen/filter/base.rb
-- lib/text/gen/filter/item/locale.rb
-- lib/text/gen/filter/item/reject.rb
-- lib/text/gen/filter/item/select.rb
-- lib/text/gen/filter/item_filter.rb
-- lib/text/gen/filter/result/capitalize.rb
-- lib/text/gen/filter/result/censor.rb
-- lib/text/gen/filter/result/clear.rb
-- lib/text/gen/filter/result/downcase.rb
-- lib/text/gen/filter/result/exclude.rb
-- lib/text/gen/filter/result/match.rb
-- lib/text/gen/filter/result/meta.rb
-- lib/text/gen/filter/result/pluralize.rb
-- lib/text/gen/filter/result/swap.rb
-- lib/text/gen/filter/result/titleize.rb
-- lib/text/gen/filter/result/upcase.rb
-- lib/text/gen/filter/result_filter.rb
+- lib/text/gen/filter/capitalize.rb
+- lib/text/gen/filter/censor.rb
+- lib/text/gen/filter/clear.rb
+- lib/text/gen/filter/distinct.rb
+- lib/text/gen/filter/downcase.rb
+- lib/text/gen/filter/exclude.rb
+- lib/text/gen/filter/locale.rb
+- lib/text/gen/filter/match.rb
+- lib/text/gen/filter/meta.rb
+- lib/text/gen/filter/pluralize.rb
+- lib/text/gen/filter/reject.rb
+- lib/text/gen/filter/remember.rb
+- lib/text/gen/filter/replace.rb
+- lib/text/gen/filter/select.rb
+- lib/text/gen/filter/swap.rb
+- lib/text/gen/filter/titleize.rb
+- lib/text/gen/filter/upcase.rb
+- lib/text/gen/investigator.rb
+- lib/text/gen/meta.rb
 - lib/text/gen/result.rb
 - lib/text/gen/result_accumulator.rb
 - lib/text/gen/runner.rb

data/lib/text/gen/filter/item/locale.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../item_filter"
-
-module Text
-  module Gen
-    module Filter
-      module Item
-        class Locale < ItemFilter
-          def apply(items)
-            items.map { |item| locale_item(item) || item }
-          end
-
-          private
-
-          def locale_item(item)
-            meta = item["meta"]
-            return if meta.nil? || meta.empty?
-
-            locale_text = meta[key.downcase]&.sample
-            return unless locale_text
-
-            Filter.constant_item(locale_text, item)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../item_filter"
-
-module Text
-  module Gen
-    module Filter
-      module Item
-        class Reject < ItemFilter
-          def apply(items)
-            items.select do |item|
-              pass_reject?(item["meta"])
-            end
-          end
-
-          private
-
-          def pass_reject?(meta)
-            return false if value == "*" && meta.key?(key)
-            return false if key == "*" && meta.values.any? { |arr| arr.include?(value) }
-
-            !meta[key]&.include?(value)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../item_filter"
-
-module Text
-  module Gen
-    module Filter
-      module Item
-        class Select < ItemFilter
-          def apply(items)
-            items.select do |item|
-              pass_select?(item["meta"])
-            end
-          end
-
-          private
-
-          def pass_select?(meta)
-            return true if value == "*" && meta.key?(key)
-            return true if key == "*" && meta.values.any? { |arr| arr.include?(value) }
-
-            meta[key]&.include?(value)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Text
-  module Gen
-    module Filter
-      # Base class for filters that operate on item arrays
-      # Subclasses should implement #apply(items) -> Array
-      class ItemFilter < Base
-        def apply(items)
-          raise NotImplementedError, "Subclasses must implement #apply(items)"
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../result_filter"
-
-module Text
-  module Gen
-    module Filter
-      module Result
-        class Capitalize < ResultFilter
-          def apply(result)
-            transform_text(result, result.text.sub(/\S/, &:upcase))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../result_filter"
-
-module Text
-  module Gen
-    module Filter
-      module Result
-        class Censor < ResultFilter
-          def apply(result)
-            return result if lookup.nil? || key.nil?
-
-            # Get the censor builder
-            builder = lookup.call(key)
-            return result unless builder
-
-            # Create a runner to evaluate each item
-            runner = Text::Gen::Runner.new(key: key, lookup: lookup)
-
-            # Run each item in the builder once
-            censor_texts = builder["items"].map do |item|
-              item_result = runner.send(:run_item, key, item, 0)
-              apply_function(item_result.text) if item_result
-            end.compact.uniq
-
-            # Get the text to compare
-            compare_text = apply_function(result.text)
-
-            # Check if result text matches any censor text
-            return nil if censor_texts.include?(compare_text)
-
-            result
-          end
-
-          private
-
-          def apply_function(text)
-            return text if value.nil? || value.empty?
-
-            case value
-            when "downcase"
-              text.downcase
-            when "upcase"
-              text.upcase
-            when "capitalize"
-              text.capitalize
-            else
-              text
-            end
-          end
-        end
-      end
-    end
-  end
-end