text-gen 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd025671968a7f3a6d7fd3dc9cc0cb1d02f06a43054c2aa8395f6db054d86c79
-  data.tar.gz: 5ff622ee28e61931406c4d3f1d792c1bc3eefde351c2bd8e22f8b285b715158d
+  metadata.gz: a407f025ce7e1835fe342ecdd09831a83fc8384c3e5bf5cebe9d63b7c9105689
+  data.tar.gz: '08254c7fc3f59de3c959d34f469813a1af7ca2114c0678641c38093e67ddc421'
 SHA512:
-  metadata.gz: eafd1508e2cac903b0f81e0c94dd47eee86d8bc8321d863f3258b5d2e730cc016a84b7cbba48e0827ba9fc6545916cd20a521d7927587eedfd017cd6561f4b35
-  data.tar.gz: 0d82d9c14341a74baea22e17cb1830f3c61559a33ca8049b0ba5fde856552ddde0a5fddb82b67b0d81a4d80505f6e8aa8894b930640d49281127a27e20d1148d
+  metadata.gz: 5faa23b1eb072b7f559269dea94a4e93096296ea8d6a197d86f3ea038b2f6d37d513afb18070174a7508f6119281e1f7f584893816b56515259287e25c32a428
+  data.tar.gz: dfec5829429cd2f2bba0f709bda7b0fd7b3402f181336755c7c05768ef79e57e41c77d4d181de070409b4be5030fc36b654e3269a055752385a54f3f9cac32bf

data/lib/text/gen/filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     class Filter
@@ -15,7 +17,9 @@ module Text
             when "upcase"
               result = Result.from(text: result.text.upcase, type: :function, result:)
             when "titleize"
-              result = Result.from(text: Titleizer.titleize(result.text), type: :function, result:)
+              result = Result.from(text: Function::Titleizer.titleize(result.text), type: :function, result:)
+            when "pluralize"
+              result = Result.from(text: Function::Pluralizer.pluralize(result.text), type: :function, result:)
             when "clear"
               result = Result.from(text: result.text, type: :function, result:)
               result.clear_meta(filter["key"], filter["value"])
@@ -66,33 +70,47 @@ module Text
 
         # Create a builder that always returns a constant value
         def constant_builder(key, str)
-          # TODO: the string should be parsed into segments
-          segments = Segment::Parser.parse(str)
           {
             "key" => key,
-            "items" => [
-              {
-                "segments" => segments,
-                "value" => 0,
-                "multiplier" => 1,
-                "filters" => [],
-                "meta" => {}
-              }
-            ],
+            "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
+
         # Replace locale is used on an item; if the item is selected and has
         # associated meta value of "locale" and the request is using that locale value
         # then replace the item text with the value of the meta. If there is
         # more than one value, select at random.
-        def replace_locale(meta, locale)
+        # Returns a new item with locale text and preserved value/multiplier, or nil
+        def replace_locale(item, locale)
           return if locale.nil?
+          return if item.nil?
+
+          meta = item["meta"]
           return if meta.nil? || meta.empty?
 
-          meta[locale.downcase]&.sample
+          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
 
         def pass_select?(meta, key, value)
@@ -110,6 +128,8 @@ module Text
         end
 
         def separator(filters)
+          return "" unless filters
+
           separator_filter = filter_by_type(filters, "separator")
           return "" unless separator_filter
           return separator_filter["value"] if separator_filter["key"] == "string"

data/lib/text/gen/filter_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     class FilterError < StandardError; end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+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",
+          "thief" => "thieves",
+          "tooth" => "teeth",
+          "wolf" => "wolves",
+          "woman" => "women"
+        }.freeze
+
+        SINGLE = Set.new(%w[a an the this that my your his her its our their])
+
+        class << self
+          def pluralize(str)
+            return str if str.empty?
+
+            arr = str.split(/\s+/)
+            return str if arr.length < 2
+
+            num = to_num(arr[0])
+            if num && num > 1
+              dc = arr[-1].downcase
+              arr[-1] = exceptions(dc) || others(dc) || ends_with_y(dc) || simple(dc)
+            end
+            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 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
+end

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

@@ -0,0 +1,24 @@
+# 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 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(" ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/max_attempts_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     class MaxAttemptsError < StandardError; end

data/lib/text/gen/max_recursion_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     class MaxRecursionError < StandardError; end

data/lib/text/gen/result.rb

@@ -73,12 +73,15 @@ module Text
           end
         end
 
-        def merge(results, separator, meta = {}, type: :sequence)
+        def merge(results, value: nil, multiplier: nil, filters: [], meta: {}, type: :sequence)
+          sep = Filter.separator(filters)
+          mul = multiplier || results.reduce(1) { |acc, r| acc * r.multiplier }
+          val = value || results.sum(&:value)
           new(
-            text: results.map(&:text).join(separator),
+            text: results.map(&:text).join(sep),
             type: type,
-            value: results.sum(&:value),
-            multiplier: results.reduce(1) { |acc, r| acc * r.multiplier }
+            value: val * mul,
+            multiplier: 1
           ).tap do |result|
             result.components.append(*results)
             result.merge_all_meta(results)

data/lib/text/gen/result_accumulator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     # ResultAccumulator handles accumulating results with attempt tracking
@@ -10,8 +12,8 @@ module Text
 
       def initialize(unique:, count:, max_attempts:)
         @unique = unique
-        @count = count
-        @max_attempts = max_attempts
+        @count = [count, 1].max
+        @max_attempts = [max_attempts, 1].max
         @results = unique ? {} : []
         @attempts = max_attempts * count
       end

data/lib/text/gen/runner.rb

@@ -49,7 +49,7 @@ module Text
       end
 
       # A builder is hash with a key field, items, filters, and meta
-      def run_builder(key, builder, filters, depth)
+      def run_builder(_key, builder, filters, depth)
         depth += 1
         raise MaxRecursionError if depth > max_recursion
 
@@ -65,24 +65,36 @@ module Text
       def run_items(strategy, items, filters, meta, depth)
         case strategy
         when "sequence"
-          sep = Filter.separator(filters)
-          run_item_sequence(items, sep, meta, depth)
+          run_item_sequence(items, filters, meta, depth)
         when "weighted"
           run_weighted_items(items, meta, depth)
         else
-          run_random_item(items, meta, depth)
+          run_random_item(strategy, items, meta, depth)
         end
       end
 
-      def run_random_item(items, meta, depth)
-        result = run_item(items.sample, depth)
+      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
+          items[total]
+        end
+      end
+
+      def run_random_item(strategy, items, meta, depth)
+        item = random_item(strategy, items)
+        return unless item
+
+        result = run_item(item, depth)
         result.merge_meta(meta)
         result
       end
 
       def run_item_sequence(items, filters, meta, depth)
         results = items.map { |item| run_item(item, depth) }
-        Result.merge(results, filters, meta, type: :sequence)
+        Result.merge(results, filters:, meta:, type: :sequence)
       end
 
       def run_weighted_items(items, meta, depth)
@@ -99,13 +111,17 @@ module Text
       end
 
       def run_item(item, depth)
-        locale_result = locale_result_for(item)
-        return locale_result if locale_result
+        return unless item
+
+        locale_item = Filter.replace_locale(item, locale)
+        item = locale_item || item
 
         results = item["segments"].map { |seg| run_segment(seg, depth) }
-        sep = Filter.separator(item["filters"])
-        result = Result.merge(results, sep)
-        result.merge_meta(item["meta"])
+        result = Result.merge(results,
+                              value: item["value"],
+                              multiplier: item["multiplier"],
+                              filters: item["filters"],
+                              meta: item["meta"])
         result = apply_result_function(result, item["filters"])
         apply_result_filters(result, item["filters"])
       end
@@ -123,16 +139,22 @@ module Text
         end
       end
 
+      def random_from_dice(text)
+        rolled = DiceNomShim.roll(text)
+        parsed = JSON.parse(rolled).first["lhs"]
+        count = parsed["values"].size
+        total = parsed["total"]
+        [total, count]
+      end
+
       def run_dice_segment(seg)
-        rolled = DiceNomShim.roll(seg["text"])
-        parsed = JSON.parse(rolled)
-        result = parsed[0].dig("lhs", "total")
-        Result.new(text: result.to_s, multiplier: result, type: :dice)
+        total, = random_from_dice(seg["text"])
+        Result.new(text: total.to_s, multiplier: total, type: :dice)
       end
 
       def run_number_segment(seg)
         num = seg["text"].to_i
-        Result.new(text: num.to_s, value: num, type: :number)
+        Result.new(text: num.to_s, multiplier: num, type: :number)
       end
 
       def run_reference_segment(seg, depth)
@@ -162,13 +184,6 @@ module Text
         items
       end
 
-      def locale_result_for(item)
-        text = Filter.replace_locale(item["meta"], locale)
-        return nil unless text
-
-        Result.new(text:, type: :locale, value: item["value"], multiplier: item["multiplier"])
-      end
-
       def to_h
         {
           "key" => key,

data/lib/text/gen/segment/constant.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     module Segment

data/lib/text/gen/segment/dice.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     module Segment

data/lib/text/gen/segment/number.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     module Segment
@@ -10,7 +12,9 @@ module Text
 
             {
               "type" => "constant",
-              "text" => str
+              "text" => str,
+              "value" => 0,
+              "multiplier" => Integer(str)
             }
           end
         end

data/lib/text/gen/segment/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "constant"
 require_relative "dice"
 require_relative "number"

data/lib/text/gen/segment/reference.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Text
   module Gen
     module Segment

data/lib/text/gen/version.rb

@@ -2,6 +2,6 @@
 
 module Text
   module Gen
-    VERSION = "0.3.0"
+    VERSION = "0.4.1"
   end
 end

data/lib/text/gen.rb

@@ -6,8 +6,9 @@ require_relative "gen/lookup_error"
 require_relative "gen/max_attempts_error"
 require_relative "gen/max_recursion_error"
 
+require_relative "gen/function/titleizer"
+require_relative "gen/function/pluralizer"
 require_relative "gen/result_accumulator"
-require_relative "gen/titleizer"
 require_relative "gen/result"
 require_relative "gen/segment/parser"
 require_relative "gen/filter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - G Palmer
@@ -42,6 +42,8 @@ files:
 - lib/text/gen.rb
 - lib/text/gen/filter.rb
 - lib/text/gen/filter_error.rb
+- lib/text/gen/function/pluralizer.rb
+- lib/text/gen/function/titleizer.rb
 - lib/text/gen/lookup_error.rb
 - lib/text/gen/max_attempts_error.rb
 - lib/text/gen/max_recursion_error.rb
@@ -54,7 +56,6 @@ files:
 - lib/text/gen/segment/parser.rb
 - lib/text/gen/segment/reference.rb
 - lib/text/gen/store.rb
-- lib/text/gen/titleizer.rb
 - lib/text/gen/version.rb
 - sig/text/gen.rbs
 homepage: https://github.com/palmergs/text-gen

data/lib/text/gen/titleizer.rb

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