text-gen 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efe92f0e6e0bb6b90a754daff918ef5900d2291d69e594afdba1e0e60ec0694a
-  data.tar.gz: 1997e875c362f9931c83df43b6a4680fcd58e1b00fa90dcca36db2aa0dd968bc
+  metadata.gz: 60294b39f992c96f317ad35a502145577250616b6955133b1502d4671af29517
+  data.tar.gz: f9fd5e105682af4c36f11632c1603425b977a59171d6c0597428761e397ce443
 SHA512:
-  metadata.gz: c7acd68aa5957831a49fb1fe9c70212873ace7da1e255019b54ca323c9ab50a7dce399ba2627b679d1b38f1dc8fbc7020e1447dd1c0dc8007fee319720acdbaa
-  data.tar.gz: a8291f893d31cdd2a993c8aa184fae8a29c14712e044c8cf4f2ae31d11ea6d2c233b13314b4fe93207382b2dd1753370e0740978d50d8bd501586d69cf2e983c
+  metadata.gz: 84dec457f1b0c2853f014f6e75f1136baa40afffebe3ac8c5e15932fd1ab8938367e30509bb26dd65cb4f50c2be9e18149d7c14a61a876a381ee632e2f9573e2
+  data.tar.gz: 7d7bb543d5fe6d6582746f807cf1d31d1e82211749ec54f8abdade318f97cb069960d3d3ef327bdef9f830a19a450506b11cc446c48f8c88218997c4d6d77b6b

data/README.md

@@ -1,28 +1,50 @@
 # Text::Gen
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/text/gen`. To experiment with that code, run `bin/console` for an interactive prompt.
+A Ruby gem for building random text strings from rules defined as Ruby hashes. Rules consist of Builders containing Items composed of Segments. Generated text can be modified with filters like pluralize, capitalize, and titleize.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'text-gen'
+```
 
-Install the gem and add to the application's Gemfile by executing:
+And then execute:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle install
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+Or install it yourself as:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install text-gen
 ```
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require 'text/gen'
+
+# Define builders with items and filters
+random_fruit = {
+  "items" => [{ "segments" => Text::Gen::Segment::Parser.parse("[d4] [fruit]") }],
+  "filters" => [{ "type" => "pluralize" }, { "type" => "titleize" }]
+}
+
+fruit = {
+  "items" => %w[apple banana orange pear kiwi].map { |f| { "segments" => Text::Gen::Segment::Parser.parse(f) } }
+}
+
+# Create a lookup function
+lookup = lambda { |key| key == "random-fruit" ? random_fruit : fruit }
+
+# Run the generator
+runner = Text::Gen::Runner.new(key: "random-fruit", lookup: lookup)
+result = runner.run.first
+puts result.text # => "3 Bananas"
+```
 
 ## Development
 
@@ -32,7 +54,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/text-gen. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/text-gen/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/palmergs/text-gen. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/palmergs/text-gen/blob/release/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -40,4 +62,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Text::Gen project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/text-gen/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Text::Gen project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/palmergs/text-gen/blob/release/CODE_OF_CONDUCT.md).

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Text
+  module Gen
+    module Filter
+      # Base class for all filters
+      # Provides common utilities and template method pattern
+      class Base
+        attr_reader :filter, :lookup
+
+        def initialize(filter = {}, lookup: nil)
+          @filter = filter
+          @lookup = lookup
+        end
+
+        # Template method - must be implemented by subclasses
+        def apply(input)
+          raise NotImplementedError, "Subclasses must implement #apply"
+        end
+
+        # Shared utilities
+        def key
+          filter["key"]
+        end
+
+        def value
+          filter["value"]
+        end
+
+        def type
+          filter["type"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,17 @@
+# 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.capitalize)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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, 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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../result_filter"
+
+module Text
+  module Gen
+    module Filter
+      module Result
+        class Clear < ResultFilter
+          def apply(result)
+            transform_with_meta(result) do |new_result|
+              new_result.clear_meta(key, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../result_filter"
+
+module Text
+  module Gen
+    module Filter
+      module Result
+        class Exclude < ResultFilter
+          def apply(result)
+            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
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../result_filter"
+
+module Text
+  module Gen
+    module Filter
+      module Result
+        class Match < ResultFilter
+          def apply(result)
+            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
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../result_filter"
+
+module Text
+  module Gen
+    module Filter
+      module Result
+        class Meta < ResultFilter
+          def apply(result)
+            transform_with_meta(result) do |new_result|
+              meta_value = case value
+                           when "_text_"
+                             result.text
+                           when "_value_"
+                             result.value.to_s
+                           when "_multiplier_"
+                             result.multiplier.to_s
+                           when "_length_"
+                             result.text.length.to_s
+                           else
+                             value
+                           end
+              new_result.merge_kv(key, meta_value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/{function/pluralizer.rb → filter/result/pluralize.rb}

@@ -1,37 +1,41 @@
 # frozen_string_literal: true
 
+require "set"
+require_relative "../result_filter"
+
 module Text
   module Gen
-    module Function
-      class Pluralizer
-        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])
-
-        class << self
-          def apply(result, _filter)
-            text = pluralize(result.text)
-            Result.from(text:, type: :function, result:)
+    module Filter
+      module Result
+        class Pluralize < ResultFilter
+          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 apply(result)
+            transform_text(result, pluralize(result.text))
           end
 
+          private
+
           def pluralize(str)
             return str if str.empty?
 

data/lib/text/gen/{function/swapper.rb → filter/result/swap.rb}

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "../result_filter"
+
 module Text
   module Gen
-    module Function
-      class Swapper
-        DIGIT_WORDS = {
-          "1" => "one", "2" => "two", "3" => "three",
-          "4" => "four", "5" => "five", "6" => "six",
-          "7" => "seven", "8" => "eight", "9" => "nine"
-        }.freeze
-
-        class << self
-          def apply(result, filter)
-            text = swap(result.text, filter["key"], filter["value"])
-            Result.from(text:, type: :function, result:)
+    module Filter
+      module Result
+        class Swap < ResultFilter
+          DIGIT_WORDS = {
+            "1" => "one", "2" => "two", "3" => "three",
+            "4" => "four", "5" => "five", "6" => "six",
+            "7" => "seven", "8" => "eight", "9" => "nine"
+          }.freeze
+
+          def apply(result)
+            transform_text(result, swap(result.text, key, value))
           end
 
+          private
+
           def swap(str, key, val)
             return str if key.nil? || key.empty?
 

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "../result_filter"
+
+module Text
+  module Gen
+    module Filter
+      module Result
+        class Titleize < ResultFilter
+          SKIP_WORDS = Set.new(%w[a an and as at but by for if in of on or the to v via vs])
+
+          def apply(result)
+            transform_text(result, titleize(result.text))
+          end
+
+          private
+
+          def titleize(str)
+            str.split(/\s+/).map.with_index do |word, idx|
+              idx.zero? || !SKIP_WORDS.include?(word) ? word.capitalize : word
+            end.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Text
+  module Gen
+    module Filter
+      # Base class for filters that operate on Result objects
+      # Subclasses should implement #apply(result) -> Result or nil
+      class ResultFilter < Base
+        def apply(result)
+          raise NotImplementedError, "Subclasses must implement #apply(result)"
+        end
+
+        protected
+
+        # Helper to create a new result preserving metadata
+        def transform_text(result, new_text)
+          Text::Gen::Result.from(text: new_text, type: :function, result: result)
+        end
+
+        # Helper to create a new result and modify metadata
+        def transform_with_meta(result, new_text = nil)
+          new_result = Text::Gen::Result.from(
+            text: new_text || result.text,
+            type: :function,
+            result: result
+          )
+          yield new_result if block_given?
+          new_result
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/filter.rb

@@ -1,37 +1,60 @@
 # frozen_string_literal: true
 
-require_relative "function/capitalizer"
-require_relative "function/clear"
-require_relative "function/downcase"
-require_relative "function/meta"
-require_relative "function/pluralizer"
-require_relative "function/swapper"
-require_relative "function/titleizer"
-require_relative "function/upcase"
+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/select"
+require_relative "filter/item/reject"
 
 module Text
   module Gen
-    class Filter
+    module Filter
       SEPARATORS = { "tab" => "\t", "newline" => "\n", "space" => " " }.freeze
 
-      FUNCTION_CLASSES = {
-        "capitalize" => Function::Capitalizer,
-        "clear" => Function::Clear,
-        "downcase" => Function::Downcase,
-        "meta" => Function::Meta,
-        "pluralize" => Function::Pluralizer,
-        "swap" => Function::Swapper,
-        "titleize" => Function::Titleizer,
-        "upcase" => Function::Upcase
+      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 = {
+        "select" => Filter::Item::Select,
+        "reject" => Filter::Item::Reject
       }.freeze
 
       class << self
-        def functions(result, filters)
+        def functions(result, filters, lookup: nil)
           return result if filters.nil? || filters.empty?
 
           filters.each do |filter|
-            function_class = FUNCTION_CLASSES[filter["type"]]
-            result = function_class.apply(result, filter) if function_class
+            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
@@ -41,8 +64,12 @@ module Text
           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? { |f| pass_select?(item["meta"], f["key"], f["value"]) }
+            select_filters.any? do |filter|
+              filter_instance = ITEM_FILTER_CLASSES["select"].new(filter)
+              filter_instance.apply([item]).any?
+            end
           end
         end
 
@@ -50,25 +77,34 @@ module Text
           reject_filters = filters_by_type(filters, "reject")
           return items if reject_filters.empty?
 
-          items.select do |item|
-            reject_filters.all? { |f| pass_reject?(item["meta"], f["key"], f["value"]) }
+          # 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?
-          return result if match_filters.any? { |f| pass_select?(result.meta, f["key"], f["value"]) }
 
-          nil
+          # 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?
-          return result if exclude_filters.all? { |f| pass_reject?(result.meta, f["key"], f["value"]) }
 
-          nil
+          # 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
@@ -111,20 +147,6 @@ module Text
           constant_item(locale_text, item)
         end
 
-        def pass_select?(meta, key, value)
-          return true if value == "*" && meta.key?(key)
-          return true if key == "*" && meta.values.any? { |arr| arr.include?(value) }
-
-          meta[key]&.include?(value)
-        end
-
-        def pass_reject?(meta, key, value)
-          return false if value == "*" && meta.key?(key)
-          return false if key == "*" && meta.values.any? { |arr| arr.include?(value) }
-
-          !meta[key]&.include?(value)
-        end
-
         def separator(filters)
           return "" unless filters
 

data/lib/text/gen/runner.rb

@@ -202,7 +202,7 @@ module Text
       end
 
       def apply_result_function(result, filters)
-        Filter.functions(result, filters)
+        Filter.functions(result, filters, lookup: lookup)
       end
 
       def merge_filters(builder, filters)

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.7.1"
+    VERSION = "0.8.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - G Palmer
@@ -42,14 +42,22 @@ files:
 - Rakefile
 - lib/text/gen.rb
 - lib/text/gen/filter.rb
-- lib/text/gen/function/capitalizer.rb
-- lib/text/gen/function/clear.rb
-- lib/text/gen/function/downcase.rb
-- lib/text/gen/function/meta.rb
-- lib/text/gen/function/pluralizer.rb
-- lib/text/gen/function/swapper.rb
-- lib/text/gen/function/titleizer.rb
-- lib/text/gen/function/upcase.rb
+- lib/text/gen/filter/base.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/result.rb
 - lib/text/gen/result_accumulator.rb
 - lib/text/gen/runner.rb

data/lib/text/gen/function/capitalizer.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Capitalizer
-        class << self
-          def apply(result, _filter)
-            text = result.text.capitalize
-            Result.from(text:, type: :function, result:)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Clear
-        class << self
-          def apply(result, filter)
-            new_result = Result.from(text: result.text, type: :function, result:)
-            new_result.clear_meta(filter["key"], filter["value"])
-            new_result
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Downcase
-        class << self
-          def apply(result, _filter)
-            text = result.text.downcase
-            Result.from(text:, type: :function, result:)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Meta
-        class << self
-          def apply(result, filter)
-            new_result = Result.from(text: result.text, type: :function, result:)
-            new_result.merge_kv(filter["key"], filter["value"])
-            new_result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/text/gen/function/titleizer.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Titleizer
-        SKIP_WORDS = Set.new(%w[a an and as at but by for if in of on or the to v via vs])
-
-        class << self
-          def apply(result, _filter)
-            text = titleize(result.text)
-            Result.from(text:, type: :function, result:)
-          end
-
-          def titleize(str)
-            str.split(/\s+/).map.with_index do |word, idx|
-              idx.zero? || !SKIP_WORDS.include?(word) ? word.capitalize : word
-            end.join(" ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Text
-  module Gen
-    module Function
-      class Upcase
-        class << self
-          def apply(result, _filter)
-            text = result.text.upcase
-            Result.from(text:, type: :function, result:)
-          end
-        end
-      end
-    end
-  end
-end