text-gen 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 543ce4b1d5a3de721151f4bac870f99a1ffb27561a3fed7130ee8d0d23f19111
-  data.tar.gz: 83a723588f5df04a3df5ba3fdb04f003fa807213c5a694a9f248d389e71b60f4
+  metadata.gz: a96a06698a3f29093011dac3d0f9311741ffa92707ee42d685837480efaf458e
+  data.tar.gz: 3d6a85c17d38b8e2f13c203744e088efe7ff12d1f8d0eebc26551d9b94a0d9c7
 SHA512:
-  metadata.gz: e4f57b53c1039e79f49086b5eaadad99d01f1eec2159fe2d8efcc077ecd821d62ab98c8b28b8b3af0a88d6cd806d0e536d673b5bc37e55d15fc19aa4a2bc317e
-  data.tar.gz: 5eaa403665e1873d7602a16bc9b83c6be795ac41f0db6c03eab10d25fdc66b67535135092997685e531285a894ccad7416c4a7625e876155ab4997a3699dff64
+  metadata.gz: bbcf087725fc5fa33da6427ddd0ff10e0482083a1e8193c37a2a609e63bf2a1932c4763bae0811ff29d489e70736a6e47e46503b0010f1a90db84dbd18f5fc0f
+  data.tar.gz: c4cc7a812869a52bab81fcd78dfcebea2c64951b09299ccdb9c7f1cda7cc05b65635082cb15c03d0ff61ae248eb031f166edce39c3da52cbe1e4ce379a3d47b9

data/lib/text/gen/context.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    # Keep the context for one run.
+    class Context
+      attr_reader :store, :depth
+
+      def initialize(store:, filters: nil, meta: nil, max_recursion: 10)
+        @depth = 0
+        @store = store
+
+        # Request filters are added to the top level builder
+        @filters = (filters || []).map { |hsh| Filter.build(hsh, 1) }.compact
+        @meta = meta
+        @keys = []
+        @strategy_stack = []
+        @remember = Hash.new { |h, k| h[k] = [] }
+        @max_recursion = max_recursion
+      end
+
+      def descend!(builder)
+        @depth += 1
+        @keys << builder["key"]
+        @strategy_stack << (builder["strategy"] || "random").split(":", 2)
+        raise MaxRecursionError if @depth > @max_recursion
+      end
+
+      def ascend!
+        @depth -= 1
+        @keys.pop
+        @strategy_stack.pop
+      end
+
+      def with_filters(filters, offset: 0)
+        count = 0
+        (filters || []).each do |hsh|
+          filter = Filter.build(hsh, depth + offset)
+          next unless filter
+
+          count += 1
+          @filters << filter
+        end
+
+        result = yield
+
+        @filters.pop(count)
+        result
+      end
+
+      def current_key
+        @keys.last
+      end
+
+      def current_strategy
+        @strategy_stack.last&.first || "random"
+      end
+
+      def current_modifier
+        @strategy_stack.last&.[](1)
+      end
+
+      def remember(result)
+        @remember[current_key] << result
+        result
+      end
+
+      def remembered(key = nil)
+        @remember[key || current_key]
+      end
+
+      def apply_builder_filters(builder)
+        @filters.each do |filter|
+          builder = filter.builder(self, builder) if filter.respond_to?(:builder)
+          return unless builder
+          return builder if builder.is_a?(Text::Gen::Result)
+        end
+
+        builder
+      end
+
+      def apply_item_list_filters(items)
+        @filters.each do |filter|
+          items = filter.items(self, items) if filter.respond_to?(:items)
+          return [] if items.nil? || items.empty?
+        end
+
+        items
+      end
+
+      def apply_item_filters(item)
+        @filters.each do |filter|
+          item = filter.item(self, item) if filter.respond_to?(:item)
+          return unless item
+        end
+
+        item
+      end
+
+      def apply_segment_filters(segment)
+        @filters.each do |filter|
+          segment = filter.segment(self, segment) if filter.respond_to?(:segment)
+          return if segment.nil? || segment.empty?
+        end
+
+        [segment]
+      end
+
+      def apply_result_filters(result)
+        @filters.each do |filter|
+          result = filter.result(self, result) if filter.respond_to?(:result)
+          return unless result
+        end
+
+        result
+      end
+    end
+  end
+end

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

@@ -6,33 +6,36 @@ module Text
       # Base class for all filters
       # Provides common utilities and template method pattern
       class Base
-        attr_reader :filter, :lookup
-
-        def initialize(filter = {}, lookup: nil)
+        def initialize(filter, depth)
           @filter = filter
-          @lookup = lookup
-        end
-
-        # Template method - must be implemented by subclasses
-        def apply(input)
-          raise NotImplementedError, "Subclasses must implement #apply"
+          @depth = depth
         end
 
         def component_key
-          "function:#{ type }"
+          "function:#{type}"
         end
 
         # Shared utilities
         def key
-          filter["key"]
+          return @key if defined?(@key)
+
+          @key = @filter["key"].nil? || @filter["key"].empty? ? nil : @filter["key"]
         end
 
         def value
-          filter["value"]
+          return @value if defined?(@value)
+
+          @value = @filter["value"].nil? || @filter["value"].empty? ? nil : @filter["value"]
         end
 
         def type
-          filter["type"]
+          @type ||= @filter["type"]
+        end
+
+        class << self
+          def filter_name
+            @filter_name ||= name.split("::").last.downcase
+          end
         end
       end
     end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Capitalize < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          text = result.text
+          text = key == "force" ? text.capitalize : text.sub(/\S/, &:upcase)
+          return result if text == result.text
+
+          Result.from(result, text:, type: component_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Censor < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+          return result if key.nil?
+
+          builder = context.store.fetch(key)
+          return result unless builder
+
+          # Build a list of censor texts
+          runner = Text::Gen::Runner.new(key:, lookup: nil)
+          censor = Context.new(context.store)
+          list = builder["items"].map do |item|
+            runner.run_item(censor, item)&.text
+          end.compact.uniq
+
+          # Get the text to compare
+          compare_text = apply_function(result.text)
+
+          # Return nil if result text matches any censor text
+          return if list.any? { |s| apply_function(s) == compare_text }
+
+          result
+        end
+
+        private
+
+        def apply_function(text)
+          return nil unless text
+
+          # default is case insensitve comparison
+          return text.downcase 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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      # Clears result meta
+      class Clear < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          new_meta = Text::Gen::Meta.clear_kv(result.meta, key, value)
+          return result if new_meta == result.meta
+
+          Result.from(result, type: component_key, meta: new_meta)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      # Return nil if the text value has already been generated
+      class Distinct < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          previous = context.remembered(key)
+          return nil if previous.any? { |r| r.text.strip.downcase == result.text.strip.downcase }
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Downcase < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          text = result.text
+          text = text.downcase
+          return result if text == result.text
+
+          Result.from(result, text:, type: component_key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module 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)
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      # Locale if the key on the filter matches a meta key, then
+      # the value of the key becomes a replacement item
+      #
+      # For example if a filter with the type and key of  "locale:en"
+      # were run against an item with segments of `["gracias"]` but with a meta value
+      # of `{"en": ["thanks", "thank you"]}` then a new item would replace
+      # the existing item with a randomly selected segment from the meta.
+      class Locale < Base
+        def items(_context, 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
+
+          constant_item(locale_text, item)
+        end
+
+        def constant_item(text, item)
+          segments = Segment::Parser.parse(text)
+          citem = { "segments" => segments }
+          if item
+            citem["value"] = item["value"] if item["value"]
+            citem["multiplier"] = item["multiplier"] if item["multiplier"]
+            citem["filters"] = item["filters"] if item["filters"]
+            citem["meta"] = item["meta"] if item["meta"]
+          end
+          citem
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Match < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+          return nil if result.nil?
+          return result if value == "*" && result.meta.key?(key)
+          return result if key == "*" && result.meta.values.any? { |arr| arr.include?(value) }
+          return result if result.meta[key]&.include?(value)
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Meta < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          new_meta = Text::Gen::Meta.append_kv(result.meta.dup, key, meta_value(result))
+          return result if new_meta == result.meta
+
+          Result.from(result, type: component_key, meta: new_meta)
+        end
+
+        def meta_value(result)
+          case value
+          when "_text_"
+            result.text
+          when "_value_"
+            result.value.to_s
+          when "_multiplier_"
+            result.multiplier.to_s
+          when "_words_"
+            result.text.split(/\s+/).length.to_s
+          when "_length_"
+            result.text.length.to_s
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Pluralize < Base
+        EXCEPTIONS = {
+          "foot" => "feet",
+          "axis" => "axes",
+          "child" => "children",
+          "codex" => "codices",
+          "die" => "dice",
+          "dwarf" => "dwarves",
+          "goose" => "geese",
+          "elf" => "elves",
+          "man" => "men",
+          "ox" => "oxen",
+          "cactus" => "cacti",
+          "thesis" => "theses",
+          "criterion" => "criteria",
+          "thief" => "thieves",
+          "tooth" => "teeth",
+          "wolf" => "wolves",
+          "woman" => "women"
+        }.freeze
+
+        SINGLE = Set.new(%w[a an the this his her its my your our that their])
+
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          text = result.text
+          text = pluralize(text, result.multiplier)
+          return result if text == result.text
+
+          Result.from(result, text:, type: component_key)
+        end
+
+        private
+
+        def pluralize(str, multiplier = 1)
+          return str if str.empty?
+
+          arr = str.split(/\s+/)
+          return str if arr.length < 2
+
+          idx = arr.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
+
+          return str if num.nil? || num <= 1
+          return str if idx && idx >= arr.length - 1
+
+          dc = arr[-1].downcase
+          arr[-1] = exceptions(dc) || single_letter(dc) || others(dc) || ends_with_y(dc) || simple(dc)
+          arr.join(" ")
+        end
+
+        def to_num(str)
+          return 1 if SINGLE.include?(str.downcase)
+
+          str =~ /\d+/ ? str.to_i : nil
+        end
+
+        def exceptions(str)
+          EXCEPTIONS[str]
+        end
+
+        def single_letter(str)
+          return unless str =~ /^[a-zA-Z0-9]$/
+
+          "#{str}'s"
+        end
+
+        def others(str)
+          if str.end_with?("s") || str.end_with?("x") || str.end_with?("z") || str.end_with?("ch") || str.end_with?("sh")
+            "#{str}es"
+          end
+        end
+
+        def ends_with_y(str)
+          "#{str[0..-2]}ies" if str.end_with?("y")
+        end
+
+        def simple(str)
+          "#{str}s"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Reject < Base
+        def items(_context, 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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Remember < Base
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          previous = context.remembered(key)
+          return previous.sample unless previous.nil? || previous.empty?
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Replace < Base
+        def builder(context, builder)
+          return builder unless builder["key"] == key
+
+          Result.new(text: value, type: "replace")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Select < Base
+        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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Swap < Base
+        DIGIT_WORDS = {
+          "1" => "one", "2" => "two", "3" => "three",
+          "4" => "four", "5" => "five", "6" => "six",
+          "7" => "seven", "8" => "eight", "9" => "nine"
+        }.freeze
+
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          text = result.text
+          text = swap(text, key, value)
+          return result if text == result.text
+
+          Result.from(result, text:, type: component_key)
+        end
+
+        private
+
+        def swap(str, key, val)
+          return str if key.nil? || key.empty?
+
+          arr = str.split(/\s+/)
+          arr = arr.map do |s|
+            case key
+            when "_digit_"
+              swap_digit(s)
+            else
+              swap_any(s, key, val.to_s)
+            end
+          end
+          arr.join(" ")
+        end
+
+        def swap_any(str, key, val)
+          str == key ? val : str
+        end
+
+        def swap_digit(str)
+          DIGIT_WORDS.fetch(str, str)
+        end
+      end
+    end
+  end
+end