text-gen 0.11.2 → 0.12.0

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      class Titleize < Base
+        SKIP_WORDS = Set.new(%w[a an and as at but by for if in of on or the to v via vs])
+
+        def result(context, result)
+          return result if @depth && context.depth != @depth
+
+          text = result.text
+          text = titleize(text)
+          return result if text == result.text
+
+          Result.from(result, text:, type: component_key)
+        end
+
+        private
+
+        def titleize(str)
+          str.split(/\s+/).map.with_index do |word, idx|
+            idx.zero? || !SKIP_WORDS.include?(word) ? word.sub(/\S/, &:upcase) : word
+          end.join(" ")
+        end
+      end
+    end
+  end
+end

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

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

data/lib/text/gen/filter.rb

@@ -1,183 +1,25 @@
 # frozen_string_literal: true
 
 require_relative "filter/base"
-require_relative "filter/result_filter"
-require_relative "filter/item_filter"
-
-# Result filters
-require_relative "filter/result/capitalize"
-require_relative "filter/result/censor"
-require_relative "filter/result/clear"
-require_relative "filter/result/downcase"
-require_relative "filter/result/exclude"
-require_relative "filter/result/match"
-require_relative "filter/result/meta"
-require_relative "filter/result/pluralize"
-require_relative "filter/result/swap"
-require_relative "filter/result/titleize"
-require_relative "filter/result/upcase"
-
-# Item filters
-require_relative "filter/item/locale"
-require_relative "filter/item/select"
-require_relative "filter/item/reject"
+Dir[File.join(__dir__, "filter", "*.rb")].each { |f| require f unless f.end_with?("/base.rb") }
 
 module Text
   module Gen
     module Filter
-      RESULT_FILTER_CLASSES = {
-        "capitalize" => Filter::Result::Capitalize,
-        "censor" => Filter::Result::Censor,
-        "clear" => Filter::Result::Clear,
-        "downcase" => Filter::Result::Downcase,
-        "exclude" => Filter::Result::Exclude,
-        "match" => Filter::Result::Match,
-        "meta" => Filter::Result::Meta,
-        "pluralize" => Filter::Result::Pluralize,
-        "swap" => Filter::Result::Swap,
-        "titleize" => Filter::Result::Titleize,
-        "upcase" => Filter::Result::Upcase
-      }.freeze
-
-      ITEM_FILTER_CLASSES = {
-        "locale" => Filter::Item::Locale,
-        "select" => Filter::Item::Select,
-        "reject" => Filter::Item::Reject
-      }.freeze
-
       class << self
-        def functions(result, filters, lookup: nil)
-          return result if filters.nil? || filters.empty?
-
-          filters.each do |filter|
-            filter_class = RESULT_FILTER_CLASSES[filter["type"]]
-            if filter_class
-              filter_instance = filter_class.new(filter, lookup: lookup)
-              result = filter_instance.apply(result)
-            end
-          end
-
-          result
-        end
-
-        def filter_locale(items, filters)
-          locale_filters = filters_by_type(filters, "locale")
-          return items if locale_filters.empty?
-
-          filter_instance = ITEM_FILTER_CLASSES["locale"].new(locale_filters.first)
-          filter_instance.apply(items)
-        end
-
-        def filter_select(items, filters)
-          select_filters = filters_by_type(filters, "select")
-          return items if select_filters.empty?
-
-          # OR logic: any filter matches
-          items.select do |item|
-            select_filters.any? do |filter|
-              filter_instance = ITEM_FILTER_CLASSES["select"].new(filter)
-              filter_instance.apply([item]).any?
-            end
-          end
-        end
-
-        def filter_reject(items, filters)
-          reject_filters = filters_by_type(filters, "reject")
-          return items if reject_filters.empty?
-
-          # AND logic: all filters must pass
-          reject_filters.each do |filter|
-            filter_instance = ITEM_FILTER_CLASSES["reject"].new(filter)
-            items = filter_instance.apply(items)
-          end
-          items
-        end
-
-        def result_select(result, filters)
-          match_filters = filters_by_type(filters, "match")
-          return result if match_filters.empty?
-
-          # OR logic: any filter matches
-          match_filters.any? do |filter|
-            filter_instance = RESULT_FILTER_CLASSES["match"].new(filter)
-            filter_instance.apply(result)
-          end ? result : nil
-        end
-
-        def result_reject(result, filters)
-          exclude_filters = filters_by_type(filters, "exclude")
-          return result if exclude_filters.empty?
-
-          # AND logic: all filters must pass
-          exclude_filters.all? do |filter|
-            filter_instance = RESULT_FILTER_CLASSES["exclude"].new(filter)
-            filter_instance.apply(result)
-          end ? result : nil
-        end
-
-        # Create a builder that always returns a constant value
-        def constant_builder(key, str)
-          {
-            "key" => key,
-            "items" => [constant_item(str)],
-            "meta" => {},
-            "filters" => []
-          }
-        end
-
-        def constant_item(str, item = nil)
-          segments = Segment::Parser.parse(str)
-          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
-
-        def filter_by_type(filters, type)
-          filters&.find { |f| f["type"] == type }
-        end
-
-        def filters_by_type(filters, type)
-          return [] if filters.nil? || filters.empty?
-
-          filters.select { |f| f["type"] == type }
-        end
-
-        # Returns a hash of all available filters with their parameters
-        # Filters that require explicit parameters will have an array of parameter names
-        # Filters that don't require parameters will have an empty array
         def available_filters
-          result_filters = RESULT_FILTER_CLASSES.keys.each_with_object({}) do |name, hash|
-            hash[name] = filter_parameters(name)
-          end
-
-          item_filters = ITEM_FILTER_CLASSES.keys.each_with_object({}) do |name, hash|
-            hash[name] = filter_parameters(name)
-          end
-
-          result_filters.merge(item_filters)
+          Base.subclasses
         end
 
-        private
-
-        # Define which filters require explicit parameters
-        FILTERS_WITH_PARAMETERS = {
-          "locale" => ["key"],
-          "swap" => ["key", "value"],
-          "meta" => ["key", "value"],
-          "censor" => ["key", "value"],
-          "match" => ["key", "value"],
-          "exclude" => ["key", "value"],
-          "select" => ["key", "value"],
-          "reject" => ["key", "value"]
-        }.freeze
+        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_name == hsh["type"] }
+          filter_class.new(hsh, depth) if filter_class
+        end
 
-        def filter_parameters(filter_name)
-          FILTERS_WITH_PARAMETERS.fetch(filter_name, [])
+        def key_to_hsh(key)
+          type, key, value = key.split(":", 3)
+          { "type" => type, "text" => key, "value" => value }
         end
       end
     end

data/lib/text/gen/investigator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    class Investigator
+      attr_reader :key, :lookup, :max_recursion
+
+      def initialize(key:, lookup:, max_recursion: 10)
+        @store = Store.new(lookup)
+        @key = key.to_s.downcase
+        @max_recursion = max_recursion
+      end
+
+      def investigate
+        visit_and_recurse(key, 0).sort.uniq
+      end
+
+      def visit_and_recurse(key, depth)
+        depth += 1
+        raise MaxRecursionError if depth > max_recursion
+
+        builder = store.fetch(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 StandardError
+        [key]
+      end
+    end
+  end
+end

data/lib/text/gen/meta.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    class Meta
+      class << self
+        def merge_meta(lhs, rhs)
+          return {} unless lhs && rhs
+          return lhs.dup if rhs.empty?
+          return rhs.dup if lhs.empty?
+
+          hsh = {}
+          lhs.each { |k, v| append_kv(hsh, k, v) }
+          rhs.each { |k, v| append_kv(hsh, k, v) }
+          hsh
+        end
+
+        def append_kv(hsh, key, val)
+          key = key.to_s.downcase
+          arr = val.is_a?(Array) ? val : Array(val)
+          hsh[key] = hsh.key?(key) ? (hsh[key] + arr).uniq : arr.dup
+          hsh
+        end
+
+        def clear_kv(hsh, key, val)
+          return {} if key == "*" && val == "*"
+
+          new_hsh = {}
+          if key == "*"
+            hsh.each_key { |k| new_hsh[k] = hsh[k].dup.reject { |v| v == val } }
+          elsif val == "*"
+            hsh.each_key { |k| new_hsh[k] = hsh[k].dup unless k == key }
+          else
+            hsh.each_key do |k|
+              if hsh.key?(k)
+                new_hsh[k] = k == key ? hsh[k].select { |v| v != val } : hsh[k].dup
+              end
+            end
+          end
+
+          new_hsh
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/result.rb

@@ -30,35 +30,19 @@ module Text
       end
 
       def merge_all_meta(results)
-        return unless results
-
-        results.each do |r|
-          r.meta.each { |k, v| merge_kv(k, v) }
-        end
+        (results || []).each { |r| @meta = Text::Gen::Meta.merge_meta(meta, r.meta) }
       end
 
       def merge_meta(hsh)
-        return unless hsh
-
-        hsh.each { |k, v| merge_kv(k, v) }
+        @meta = Text::Gen::Meta.merge_meta(meta, hsh)
       end
 
       def merge_kv(key, val)
-        key = key.to_s.downcase
-        arr = val.is_a?(Array) ? val : Array(val)
-        meta[key] = meta.key?(key) ? (meta[key] + arr).uniq : arr.dup
+        Text::Gen::Meta.append_kv(meta, key, val)
       end
 
       def clear_meta(key, val)
-        if key == "*" && val == "*"
-          @meta = {}
-        elsif key == "*"
-          @meta.each_value { |v| v.delete(val) }
-        elsif val == "*"
-          @meta.delete(key)
-        else
-          @meta[key]&.delete(val)
-        end
+        @meta = Text::Gen::Meta.clear_kv(meta, key, val)
       end
 
       def to_s
@@ -66,12 +50,13 @@ module Text
       end
 
       class << self
-        def from(text:, type:, result:, value: nil, multiplier: nil)
+        def from(result, type:, text: nil, value: nil, multiplier: nil, meta: nil)
+          text ||= result.text
           value ||= result.value
           multiplier ||= result.multiplier
           new(text:, type:, value:, multiplier:).tap do |s|
             s.components.append(result)
-            s.merge_meta(result.meta)
+            s.merge_meta(meta || result.meta)
           end
         end
 

data/lib/text/gen/result_accumulator.rb

@@ -5,16 +5,15 @@ module Text
     # ResultAccumulator handles accumulating results with attempt tracking
     class ResultAccumulator
       class << self
-        def accumulate(unique:, count:, max_attempts:, &)
-          new(unique: unique, count: count, max_attempts: max_attempts).accumulate(&)
+        def accumulate(count:, max_attempts:, &)
+          new(count: count, max_attempts: max_attempts).accumulate(&)
         end
       end
 
-      def initialize(unique:, count:, max_attempts:)
-        @unique = unique
+      def initialize(count:, max_attempts:)
         @count = [count, 1].max
         @max_attempts = [max_attempts, 1].max
-        @results = unique ? {} : []
+        @results = []
         @attempts = max_attempts * count
       end
 
@@ -27,17 +26,13 @@ module Text
           raise MaxAttemptsError if @attempts.zero?
         end
 
-        @results.map { |_, v| v }
+        @results
       end
 
       private
 
       def add_result(result)
-        if @unique
-          @results[result.text] = result
-        else
-          @results << [result.text, result]
-        end
+        @results << result
       end
     end
   end