text-gen 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a797ffbcfad9d7ad94943ea650e8fa0fa92f88e305035b2085d9500849f3bd87
-  data.tar.gz: dbf62805408bd3258a0153d83a716e29d650d8f7c37cefaa2b9090a6518f3355
+  metadata.gz: a974f3f11c14b16da1838a5a8c53395b41c33e08c7adfc32c36306ea79f9d602
+  data.tar.gz: 3b389b465cb6b135fae0c11060e42a1bd45e26e484c946180ae2b54452a4dba7
 SHA512:
-  metadata.gz: 0a5df8167670c236ead54c4c9cb63abe9fd8340c46f0bda70eac50255189ca0aa21ac6cf6305ddd451f2d10ef3af0314262cd48955f801f4b8e1e7fa1cff0d7b
-  data.tar.gz: 7b1035f58a41888f6e48b3ae56cb948d49eed2b549128fb333d95f7df2686d5831156d4cfd3b271813cb44a387d406eadcfed6cf507e8236d98636b043ac752c
+  metadata.gz: 9354feb07dec71c9f35a149c1d3ed6a7b82db54a91d8bcdf77d044659cc1907539358bae8e78befcb44c7ee139bd5edee90c07901a3b991049301aab83c4e1ad
+  data.tar.gz: df9160a73bddb71420d441e376da8882cc42c42beccac551c21b4a994b7ea8bd42892c8acee82f177ef0eb03bf6c81b7a2109bb9baa0129dc719a4e390d4584d

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,31 @@ module Text
           nil
         end
 
+        # Create a builder that always returns a constant value
+        def constant_builder(key, str)
+          {
+            "key" => key,
+            "items" => [
+              {
+                "segments" => [
+                  {
+                    "type" => "constant",
+                    "text" => str,
+                    "meta" => {},
+                    "filters" => []
+                  }
+                ],
+                "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 +119,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/version.rb

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

data/lib/text/gen.rb

@@ -6,6 +6,7 @@ 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/filter"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: text-gen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - G Palmer
@@ -45,6 +45,7 @@ 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/store.rb
 - lib/text/gen/titleizer.rb