text-gen 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a797ffbcfad9d7ad94943ea650e8fa0fa92f88e305035b2085d9500849f3bd87
-  data.tar.gz: dbf62805408bd3258a0153d83a716e29d650d8f7c37cefaa2b9090a6518f3355
+  metadata.gz: fd025671968a7f3a6d7fd3dc9cc0cb1d02f06a43054c2aa8395f6db054d86c79
+  data.tar.gz: 5ff622ee28e61931406c4d3f1d792c1bc3eefde351c2bd8e22f8b285b715158d
 SHA512:
-  metadata.gz: 0a5df8167670c236ead54c4c9cb63abe9fd8340c46f0bda70eac50255189ca0aa21ac6cf6305ddd451f2d10ef3af0314262cd48955f801f4b8e1e7fa1cff0d7b
-  data.tar.gz: 7b1035f58a41888f6e48b3ae56cb948d49eed2b549128fb333d95f7df2686d5831156d4cfd3b271813cb44a387d406eadcfed6cf507e8236d98636b043ac752c
+  metadata.gz: eafd1508e2cac903b0f81e0c94dd47eee86d8bc8321d863f3258b5d2e730cc016a84b7cbba48e0827ba9fc6545916cd20a521d7927587eedfd017cd6561f4b35
+  data.tar.gz: 0d82d9c14341a74baea22e17cb1830f3c61559a33ca8049b0ba5fde856552ddde0a5fddb82b67b0d81a4d80505f6e8aa8894b930640d49281127a27e20d1148d

data/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)"
+    ]
+  }
+}

data/lib/text/gen/filter.rb

@@ -1,6 +1,7 @@
 module Text
   module Gen
     class Filter
+      SEPARATORS = { "tab" => "\t", "newline" => "\n", "space" => " " }.freeze
       class << self
         def functions(result, filters)
           return result if filters.nil? || filters.empty?
@@ -63,6 +64,26 @@ module Text
           nil
         end
 
+        # 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" => {}
+              }
+            ],
+            "meta" => {},
+            "filters" => []
+          }
+        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
@@ -93,16 +114,7 @@ module Text
           return "" unless separator_filter
           return separator_filter["value"] if separator_filter["key"] == "string"
 
-          case separator_filter["key"]
-          when "tab"
-            "\t"
-          when "space"
-            " "
-          when "newline"
-            "\n"
-          else
-            ""
-          end
+          SEPARATORS.fetch(separator_filter["key"], "")
         end
 
         def filter_by_type(filters, type)

data/lib/text/gen/result_accumulator.rb

@@ -0,0 +1,42 @@
+module Text
+  module Gen
+    # ResultAccumulator handles accumulating results with attempt tracking
+    class ResultAccumulator
+      class << self
+        def accumulate(unique:, count:, max_attempts:, &block)
+          new(unique: unique, count: count, max_attempts: max_attempts).accumulate(&block)
+        end
+      end
+
+      def initialize(unique:, count:, max_attempts:)
+        @unique = unique
+        @count = count
+        @max_attempts = max_attempts
+        @results = unique ? {} : []
+        @attempts = max_attempts * count
+      end
+
+      def accumulate(&block)
+        while @results.size < @count
+          result = block.call
+          add_result(result) if result
+
+          @attempts -= 1
+          raise MaxAttemptsError if @attempts.zero?
+        end
+
+        @results.map { |_, v| v }
+      end
+
+      private
+
+      def add_result(result)
+        if @unique
+          @results[result.text] = result
+        else
+          @results << [result.text, result]
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/runner.rb

@@ -5,103 +5,35 @@ require "json"
 
 module Text
   module Gen
-    # ResultAccumulator handles accumulating results with attempt tracking
-    class ResultAccumulator
-      class << self
-        def accumulate(unique:, count:, max_attempts:, &block)
-          new(unique: unique, count: count, max_attempts: max_attempts).accumulate(&block)
-        end
-      end
-
-      def initialize(unique:, count:, max_attempts:)
-        @unique = unique
-        @count = count
-        @max_attempts = max_attempts
-        @results = unique ? {} : []
-        @attempts = max_attempts * count
-      end
-
-      def accumulate(&block)
-        while @results.size < @count
-          result = block.call
-          add_result(result) if result
-
-          @attempts -= 1
-          raise MaxAttemptsError if @attempts.zero?
-        end
-
-        @results.map { |_, v| v }
-      end
-
-      private
-
-      def add_result(result)
-        if @unique
-          @results[result.text] = result
-        else
-          @results << [result.text, result]
-        end
-      end
-    end
-
-    # AltLookup handles alternative filter lookups
-    class AltLookup
-      def initialize(request_filters)
-        @filters = {}
-        populate(request_filters)
-      end
-
-      def key?(key)
-        @filters.key?(key)
-      end
-
-      def [](key)
-        @filters[key]
-      end
-
-      private
-
-      def populate(request_filters)
-        request_filters.each do |f|
-          next unless f["type"] == "alt"
-
-          k = f["key"]
-          v = f["value"]
-          raise FilterError, "Invalid alt filter" if k.nil? || v.nil? || k.empty?
-
-          (@filters[k.to_s.downcase] ||= []) << v
-        end
-      end
-    end
-
     # Runner generates results from the builder that is found with the given key.
     class Runner
-      attr_reader :key, :locale, :lookup, :store, :max_attempts, :max_recursion
-
-      def initialize(
-        key:,
-        lookup:,
-        locale: nil,
-        unique: false,
-        max_recursion: 10,
-        max_attempts: 10,
-        request_filters: []
-      )
+      attr_reader :key, :lookup, :max_attempts, :max_recursion
+      attr_accessor :unique, :locale, :store
+
+      def initialize(key:, lookup:, max_recursion: 10, max_attempts: 10, request_filters: [])
         @key = key.to_s.downcase
         @lookup = lookup
-        @locale = locale
+        @locale = nil
         @store = Store.new
-        @unique = unique
+        @unique = false
         @request_filters = request_filters
         @max_attempts = max_attempts
         @max_recursion = max_recursion
-        @alt_lookup = AltLookup.new(request_filters)
+        populate_replace
       end
 
       def unique?
         @unique
       end
 
+      # A filter of type "replace:key:value" creates a temporary builder
+      # that always returns the given value.
+      def populate_replace
+        @request_filters.each do |f|
+          store.add(f["key"], Filter.constant_builder(f["key"], f["value"])) if f["type"] == "replace"
+        end
+      end
+
       def run(count: 1)
         builder = fetch_builder(key)
 
@@ -111,8 +43,8 @@ module Text
       end
 
       def fetch_builder(key)
-        builder = store.find(key) || lookup.call(key)
-        store.add(key, builder)
+        builder = @store.find(key) || lookup.call(key)
+        @store.add(key, builder)
         builder
       end
 
@@ -121,9 +53,6 @@ module Text
         depth += 1
         raise MaxRecursionError if depth > max_recursion
 
-        alt_result = alt_result_for(key, builder)
-        return alt_result if alt_result
-
         current_filters = merge_filters(builder, filters)
         current_items = apply_item_filters(builder["items"], current_filters)
 
@@ -233,12 +162,6 @@ module Text
         items
       end
 
-      def alt_result_for(key, builder)
-        return nil unless @alt_lookup.key?(builder["key"])
-
-        Result.new(text: @alt_lookup[key], type: :alt, meta: builder["meta"])
-      end
-
       def locale_result_for(item)
         text = Filter.replace_locale(item["meta"], locale)
         return nil unless text

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

@@ -0,0 +1,20 @@
+module Text
+  module Gen
+    module Segment
+      class Constant
+        TEXT = /(?:(?:\\\[)|(?:\\\])|[^\[\]])+/
+        class << self
+          def scan(scanner)
+            str = scanner.scan(TEXT)
+            return unless str
+
+            {
+              "type" => "constant",
+              "text" => str
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Text
+  module Gen
+    module Segment
+      class Dice
+        DICE_MATCHER = /\[\s*(\d*[dD]\d+(?:\s*[+x-]\s*\d+)?)\s*\]/
+        class << self
+          def scan(scanner)
+            str = scanner.scan(DICE_MATCHER)
+            return unless str
+
+            {
+              "type" => "dice",
+              "text" => scanner[1]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Text
+  module Gen
+    module Segment
+      class Number
+        NUMBER_MATCHER = /([+-]?\d+)/
+        class << self
+          def scan(scanner)
+            str = scanner.scan(NUMBER_MATCHER)
+            return unless str
+
+            {
+              "type" => "constant",
+              "text" => str
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require_relative "constant"
+require_relative "dice"
+require_relative "number"
+require_relative "reference"
+
+module Text
+  module Gen
+    module Segment
+      class Parser
+        class SegmentParseError < StandardError; end
+        class << self
+          def parse(str)
+            segments = []
+            scanner = StringScanner.new(str)
+            until scanner.eos?
+              seg = Dice.scan(scanner) || Reference.scan(scanner) || Number.scan(scanner) || Constant.scan(scanner)
+              raise SegmentParseError, "Invalid segment: #{scanner.rest}" unless seg
+
+              segments << seg
+            end
+            segments
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Text
+  module Gen
+    module Segment
+      class Reference
+        REFERENCE_MATCHER = /\[\s*([a-z0-9-]+(?::[a-z0-9i]+)*)\s*\]/
+        class << self
+          def scan(scanner)
+            str = scanner.scan(REFERENCE_MATCHER)
+            return unless str
+
+            {
+              "type" => "reference",
+              "text" => scanner[1],
+              "filters" => [],
+              "meta" => {}
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/text/gen/version.rb

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

data/lib/text/gen.rb

@@ -6,8 +6,10 @@ require_relative "gen/lookup_error"
 require_relative "gen/max_attempts_error"
 require_relative "gen/max_recursion_error"
 
+require_relative "gen/result_accumulator"
 require_relative "gen/titleizer"
 require_relative "gen/result"
+require_relative "gen/segment/parser"
 require_relative "gen/filter"
 require_relative "gen/store"
 require_relative "gen/runner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - G Palmer
@@ -33,6 +33,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/settings.local.json"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -45,7 +46,13 @@ files:
 - lib/text/gen/max_attempts_error.rb
 - lib/text/gen/max_recursion_error.rb
 - lib/text/gen/result.rb
+- lib/text/gen/result_accumulator.rb
 - lib/text/gen/runner.rb
+- lib/text/gen/segment/constant.rb
+- lib/text/gen/segment/dice.rb
+- lib/text/gen/segment/number.rb
+- 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