text-gen 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49044057cb087e22b62a113c84d6575c3bd23e1320a841cbebf650bd244c0edb
-  data.tar.gz: c4a93ede17d96f95f218060503d4d9cd527e69c3d75c3759bb2479fe6dbbc47f
+  metadata.gz: a45d470fc7741737db5056376f2d72ce0aba37634166e19038249a860c23dee0
+  data.tar.gz: 394a4dca77c33b151bb64b83f92e717f6ddff0fa653f20ffa8bcf508f7bbad02
 SHA512:
-  metadata.gz: 606e6034518c44efad32c68b559daff0dabad3d96e09d3bd22394b47e77c03d17f0aa3259e812d285a226c070f4223b1627204ff07a71d54ab733a8da5ec611e
-  data.tar.gz: b3deabab0cd407e5723ad275cdbda413728b515b62d836bf69a4a75642dae9082165956f0f2b5c09ab8adaa7936a0bdb6713a8eb89bec6b206859a905c7aed8f
+  metadata.gz: 92c649a990e045d937b503bcd9eaa2ac3e64c1f60a3846ba4842b410f4b063e27772c35b3fe53a9b95c998dfdcaf568edef03b077686c37e075539dda72d229a
+  data.tar.gz: c5da5b4dcff94578ff48fa3b03ebd197376baf67755d4dbc0b23f8bc2e857b3ec7e4be8afee209b97aefa417b4f1008f1c8dd7c370e5fe1e0ee1ee44de6a7464

data/lib/text/gen/filter.rb

@@ -1,46 +1,37 @@
 # 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"
 
 module Text
   module Gen
     class 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
+      }.freeze
+
       class << self
         def functions(result, filters)
           return result if filters.nil? || filters.empty?
 
           filters.each do |filter|
-            case filter["type"]
-            when "capitalize"
-              text = Function::Capitalizer.capitalize(result.text)
-              result = Result.from(text:, type: :function, result:)
-            when "downcase"
-              result = Result.from(text: result.text.downcase, type: :function, result:)
-            when "upcase"
-              result = Result.from(text: result.text.upcase, type: :function, result:)
-            when "titleize"
-              text = Function::Titleizer.titleize(result.text)
-              result = Result.from(text:, type: :function, result:)
-            when "pluralize"
-              text = Function::Pluralizer.pluralize(result.text)
-              result = Result.from(text:, type: :function, result:)
-            when "clear"
-              result = Result.from(text: result.text, type: :function, result:)
-              result.clear_meta(filter["key"], filter["value"])
-              result
-            when "meta"
-              result = Result.from(text: result.text, type: :function, result:)
-              result.merge_kv(filter["key"], filter["value"])
-              result
-            when "swap"
-              text = Function::Swapper.swap(result.text, filter["key"], filter["value"])
-              result = Result.from(text:, type: :function, result:)
-              result
-            end
+            function_class = FUNCTION_CLASSES[filter["type"]]
+            result = function_class.apply(result, filter) if function_class
           end
 
           result
@@ -117,11 +108,6 @@ module Text
           locale_text = meta[locale.downcase]&.sample
           return unless locale_text
 
-          # Create new item with locale text, preserving value and multiplier
-          # new_item = constant_item(locale_text)
-          # new_item["value"] = item["value"] if item["value"]
-          # new_item["multiplier"] = item["multiplier"] if item["multiplier"]
-          # new_item
           constant_item(locale_text, item)
         end
 
@@ -150,15 +136,11 @@ module Text
         end
 
         def filter_by_type(filters, type)
-          return if filters.nil?
-          return if filters.empty?
-
-          filters.find { |f| f["type"] == type }
+          filters&.find { |f| f["type"] == type }
         end
 
         def filters_by_type(filters, type)
-          return [] if filters.nil?
-          return filters if filters.empty?
+          return [] if filters.nil? || filters.empty?
 
           filters.select { |f| f["type"] == type }
         end

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

@@ -5,8 +5,9 @@ module Text
     module Function
       class Capitalizer
         class << self
-          def capitalize(str)
-            str.capitalize
+          def apply(result, _filter)
+            text = result.text.capitalize
+            Result.from(text:, type: :function, result:)
           end
         end
       end

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

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

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

@@ -0,0 +1,17 @@
+# 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/pluralizer.rb

@@ -27,6 +27,11 @@ module Text
         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:)
+          end
+
           def pluralize(str)
             return str if str.empty?
 

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

@@ -4,12 +4,21 @@ 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:)
+          end
+
           def swap(str, key, val)
             return str if key.nil? || key.empty?
 
-            puts("str=#{str} key=#{key} val=#{val}")
-
             arr = str.split(/\s+/)
             arr = arr.map do |s|
               case key
@@ -27,28 +36,7 @@ module Text
           end
 
           def swap_digit(str)
-            case str
-            when "1"
-              "one"
-            when "2"
-              "two"
-            when "3"
-              "three"
-            when "4"
-              "four"
-            when "5"
-              "five"
-            when "6"
-              "six"
-            when "7"
-              "seven"
-            when "8"
-              "eight"
-            when "9"
-              "nine"
-            else
-              str
-            end
+            DIGIT_WORDS.fetch(str, str)
           end
         end
       end

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

@@ -7,15 +7,15 @@ module Text
         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)
-            arr = str.split(/\s+/)
-            idx = 0
-            len = arr.length
-            while idx < len
-              arr[idx] = arr[idx].capitalize if idx.zero? || !SKIP_WORDS.include?(arr[idx])
-              idx += 1
-            end
-            arr.join(" ")
+            str.split(/\s+/).map.with_index do |word, idx|
+              idx.zero? || !SKIP_WORDS.include?(word) ? word.capitalize : word
+            end.join(" ")
           end
         end
       end

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

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

data/lib/text/gen/runner.rb

@@ -43,6 +43,29 @@ module Text
         end
       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 = fetch_builder(key)
+        return ["not_found:#{ key }"] unless builder
+
+        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
+      end
+
       def fetch_builder(key)
         builder = @store.find(key) || lookup.call(key)
         @store.add(key, builder)
@@ -82,15 +105,13 @@ module Text
       end
 
       def random_item(strategy, items)
-        if strategy.nil? || strategy.empty? || strategy == "random"
-          items.sample
-        else
-          total, count = random_from_dice(strategy)
-          total -= count # make the roll 0-indexed
-          raise NoItemMatched("roll #{total} exceeds #{items.length}") if total >= items.length
+        return items.sample if strategy.nil? || strategy.empty? || strategy == "random"
 
-          items[total]
-        end
+        total, count = random_from_dice(strategy)
+        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(strategy, items, meta, depth)

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.6.1"
+    VERSION = "0.7.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - G Palmer
@@ -43,9 +43,13 @@ files:
 - 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/result.rb
 - lib/text/gen/result_accumulator.rb
 - lib/text/gen/runner.rb