eunomia_gen 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda6a6807dc92353a11e090f8d61cbeb238510a8a7a0f6d524e9a90328192317
-  data.tar.gz: 0b54749ea476821a8511a355d6ddce2591128bc2417f60f8161d2405120708c4
+  metadata.gz: 2bd9d4df4c021ff782daad47aafdd3ec4e16bcabe47cccbf81cd9d5dbf3816c2
+  data.tar.gz: d5de7918c9d7d8ff2c62f7c5b4376c020442574f1dda00cc4de43529a1eafcb1
 SHA512:
-  metadata.gz: b624e0b5f19812df73cacf9bf2abab0d55078f78cf5adc6d50eac078feb6d3bdce34d2e0ba5b2b9bae1d005a7049b971465399dd142b5c29dac876e49a048aa8
-  data.tar.gz: ea823e74de17872ec4706c6648319f425e11ec9a25cf6c9581872c942d21af08495aab34e2b47f0c21142c4154759c618f00059b29674dad5196d3c5aa59496b
+  metadata.gz: b328162d070df9ed863886cae24a72e884b7b732bb5300dc42c09f7a0650de5921c008a68df9f40cfe2af6760f2ff48e51c0a2ec1f3336a56a7178628f6d8d94
+  data.tar.gz: 012fd582fb8a5726e5bd5ee55c57bbae27b8d51153f3e9e056e1f4cff81fe119a4f71cee36d03fd7da74bb76765f674f7dc0fc509fb5993d21f42b902399814a

data/.rubocop.yml

@@ -1,9 +1,20 @@
+inherit_from: .rubocop_todo.yml
+
+require: rubocop-rspec
+
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.1
+  SuggestExtensions: false
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+RSpec/ExampleLength:
+  Max: 20
+
+RSpec/MultipleExpectations:
+  Max: 5

data/.rubocop_todo.yml

@@ -0,0 +1,67 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2024-12-21 18:48:58 UTC using RuboCop version 1.66.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
+Metrics/AbcSize:
+  Max: 29
+
+# Offense count: 2
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 13
+
+# Offense count: 2
+# Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
+Metrics/ParameterLists:
+  Max: 8
+
+# Offense count: 2
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
+Naming/MethodParameterName:
+  Exclude:
+    - 'lib/eunomia/result.rb'
+    - 'lib/eunomia/segment/dice.rb'
+
+# Offense count: 1
+# Configuration parameters: Max, CountAsOne.
+RSpec/ExampleLength:
+  Exclude:
+    - 'spec/eunomia/selector_spec.rb'
+
+# Offense count: 2
+# Configuration parameters: Max.
+RSpec/MultipleExpectations:
+  Exclude:
+    - 'spec/eunomia/segment/dice_spec.rb'
+    - 'spec/eunomia/segment_spec.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedPatterns.
+# AllowedPatterns: ^expect_, ^assert_
+RSpec/NoExpectationExample:
+  Exclude:
+    - 'spec/examples/**/*.rb'
+    - 'spec/eunomia/request_spec.rb'
+
+# Offense count: 1
+# Configuration parameters: Include, CustomTransform, IgnoreMethods, IgnoreMetadata.
+# Include: **/*_spec.rb
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - '**/spec/routing/**/*'
+    - 'spec/eunomia/tags_spec.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/eunomia/separator.rb'

data/README.md

@@ -71,7 +71,7 @@ data = [
 ]
 
 Eunomia.add(data)
-request = Eunomia::Request.new("fruit", alt_key: "es", unique: true, alts: { "kiwi" => "a small flightless bird" })
+request = Eunomia::Request.new("fruit", locale: "es", unique: true, alts: { "kiwi" => "a small flightless bird" })
 arr = []
 5.times { arr << request.generate.to_s }
 p arr.join(", ") # => "manzana, banana, orange, pear, a small flightless bird"
@@ -101,7 +101,7 @@ request = Eunomia::Request.new("random-fruit", functions: %w[pluralize reverse])
 p request.generate.to_s # => "3 sananab"
 
 request = Eunomia::Request.new("random-fruit", functions: %w[reverse pluralize])
-p request.generate.to_s # => "3 ikiks"
+p request.generate.to_s # => "3 iwiks"
 ```
 
 ### Weights
@@ -125,31 +125,31 @@ If the first segment is not a number the multiplier defaults to 1.
 A constant hash can be added to the request. A string that matches the hash key will be replaced by the
 constant value.
 
-### Tags and Filtering
+### Filtering
 
-Tags can be used to filter items. For example, some plant names are also used as names. So a list of
-plants could be filtered to only those that are also names to generate a character name. Tags assigned
-to an item are also added as metadat to the result if the tag is in `key:value` format.
+Filters can be used to filter items. For example, some plant names are also used as names. So a list of
+plants could be filtered to only those that are also names to generate a character name. Filters assigned
+to an item are also added as metadata to the result if the filter is in `key:value` format.
 
 ```ruby
 data = [
   { key: "plant", items: %w[[flower] [tree]] },
   { key: "flower", items: [
-      { segments: "rose", tags: %w[name:plant] },
+      { segments: "rose", filters: %w[name:plant] },
       { segments: "hydrangea" }
     ]
   },
   { key: "tree", items: [
-      { segments: "ash", tags: %w[name:plant] },
+      { segments: "ash", filters: %w[name:plant] },
       { segments: "oak" }
     ]
   }
 ]
 
 Eunomia.add(data)
-val = Eunomia.generate("plant", tags: %w[name:plant], functions: ["capitalize"])
+val = Eunomia.generate("plant", filters: %w[name:plant], functions: ["capitalize"])
 p val.to_s # => "Rose" or "Ash"
-p val.meta # => { "tag" => "name:plant" }
+p val.meta # => { "filter" => "name:plant" }
 ```
 
 ## Development

data/lib/eunomia/element.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Eunomia
+  # One generated element
   class Element
     attr_reader :orig, :str, :value, :multiplier, :meta, :children
 

data/lib/eunomia/generator.rb

@@ -6,40 +6,57 @@ module Eunomia
   class Generator
     include Eunomia::HashHelpers
 
-    attr_reader :key,
-                :aliases,
-                :alts,
-                :meta,
-                :functions,
-                :tags,
-                :items,
-                :selector,
-                :sep
+    PASS_FILTER_ATTEMPTS = 20
+
+    # Normalized identifier for this generator
+    attr_reader :key
+
+    # Key value pairs of string values to swap out for this generator results
+    attr_reader :alts
+
+    # Key vaule pair of generator keys to values; if the key is seen the value is replaced
+    # with the constant value
+    attr_reader :constants
+
+    # Functions to apply to the generated string from this generator
+    attr_reader :functions
+
+    # Filters are key value paris that must match the generated metadata to be selected
+    attr_reader :filters
+
+    # Are the items selected in order (sequence) or random
+    attr_reader :gen
+
+    # The items in this generator
+    attr_reader :items
+
+    # The random number generator used to select items
+    attr_reader :selector
 
     def initialize(hsh)
       @key = field_or_raise(hsh, :key)
-      @aliases = list_field(hsh, :aliases)
       @functions = list_field(hsh, :functions)
       @alts = hash_field(hsh, :alts)
-      @meta = meta_field(hsh)
-      @tags = tags_field(hsh)
+      @constants = hash_field(hsh, :constants)
+      @filters = filters_field(hsh)
+      @gen = field_or_nil(hsh, :gen).to_s == "sequence" ? :sequence : :random
       @selector = Eunomia::Selector.new(field_or_nil(hsh, :rng))
       @items = items_from(hsh)
       raise "Generators must have items" if @items.empty?
     end
 
+    def random?
+      gen == :random
+    end
+
+    def sequence?
+      !random?
+    end
+
     def items_from(hsh)
       list_field(hsh, :items).map do |item|
         item = { segments: item } if item.is_a?(String)
-        Eunomia::Item.new(@key, item, @tags)
-      end
-    end
-
-    def item_tags
-      @item_tags ||= begin
-        set = Set.new
-        items.each { |item| set += item.available_tags }
-        set
+        Eunomia::Item.new(@key, item)
       end
     end
 
@@ -50,22 +67,58 @@ module Eunomia
       alts[key][segment] || segment
     end
 
-    # Select items that have all the given tag values
-    def filter(tags)
-      return items if tags.empty?
+    def passes_filters?(result)
+      return true if filters.empty?
 
-      items.select { |item| item.match_tags?(tags) }
+      # For every filter defined on this generator
+      filters.all? do |key, values|
+        found = result.meta[key]
+        found && (values.include?("*") || found.any? { |f| values.include?(f) })
+      end
     end
 
     def generate(request)
-      items = filter(request.tags)
+      trys = PASS_FILTER_ATTEMPTS
+
+      loop do
+        trys -= 1
+        break if trys <= 0
+
+        result = if random?
+                   generate_random(request, items)
+                 else
+                   generate_sequence(request, items)
+                 end
+        return result if passes_filters?(result)
+      end
+
+      raise "Unable to generate a filtered result after #{PASS_FILTER_ATTEMPTS} attempts"
+    end
+
+    def generate_random(request, items)
       item = selector.select(items)
       raise "No items found for #{key}" unless item
 
       result = item.generate(request)
-      result.apply(alts, functions, locale: request.alt_key)
-      result.merge_meta(meta)
+      result.apply(alts, functions, locale: request.locale)
       result
     end
+
+    def generate_sequence(request, items)
+      result = Eunomia::Result.new(key)
+      items.each do |item|
+        result.append(item.generate(request))
+      end
+      result
+    end
+
+    def to_h
+      hsh = { key:, gen:, items: items.map(&:to_h) }
+      hsh[:rng] = selector if selector.count
+      hsh[:filters] = filters_to_tags(filters) unless filters.empty?
+      hsh[:alts] = alts unless alts.empty?
+      hsh[:functions] = functions unless functions.empty?
+      hsh
+    end
   end
 end

data/lib/eunomia/hash_helpers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Eunomia
+  # Lookup methods for hashes to kandle symbol and string keys
   module HashHelpers
     def field_or_nil(hsh, key)
       hsh[key.to_sym] || hsh[key.to_s]
@@ -25,11 +26,16 @@ module Eunomia
       field.is_a?(String) ? field.split(/\s+/) : field
     end
 
-    def tags_field(hsh)
-      tags = list_field(hsh, :tags)
-      return Set.new unless tags
+    def filters_field(hsh)
+      tags = list_field(hsh, :filters)
+      tags.each_with_object({}) do |tag, filters|
+        key, values = tag.split(":")
+        filters[key] = Set.new(values.split(","))
+      end
+    end
 
-      Set.new(tags)
+    def filters_to_tags(hsh)
+      hsh.to_a.map { |k, v| "#{k}:#{v.join(",")}" }.join(" ")
     end
 
     def alts_field(hsh)

data/lib/eunomia/item.rb

@@ -8,13 +8,12 @@ module Eunomia
     attr_reader :key,
                 :weight,
                 :value,
-                :tags,
                 :alts,
                 :meta,
                 :functions,
                 :segments
 
-    def initialize(key, hsh, add_tags = nil)
+    def initialize(key, hsh)
       @key = key
       @weight = int_field(hsh, :weight).clamp(1, 1000)
       @value = int_field(hsh, :value).clamp(0, 1_000_000)
@@ -22,22 +21,10 @@ module Eunomia
       @meta = meta_field(hsh)
       @functions = list_field(hsh, :functions)
       @segments = scan(field_or_raise(hsh, :segments)).flatten
-      @tags = tags_field(hsh)
-      @tags += add_tags if add_tags
-      @available_tags = nil
     end
 
-    def available_tags
-      @available_tags ||= begin
-        s = Set.new
-        s += tags
-        refs = segments.filter { |seg| seg.is_a?(Eunomia::Segment::Reference) }
-        unless refs.empty?
-          s = refs[0].item_tags
-          refs[1..].each { |ref| s &= ref.item_tags }
-        end
-        s
-      end
+    def meta_keys
+      @meta_keys ||= (Set.new(meta.keys) + segments.map(&:meta_keys).inject(&:merge))
     end
 
     def scan(obj)
@@ -47,14 +34,6 @@ module Eunomia
       obj.map { |e| Eunomia::Segment.build(e) }.flatten
     end
 
-    def match_tags?(tags)
-      return true if tags.nil? || tags.empty?
-      return true if (tags - self.tags).empty?
-      return true if (tags - available_tags).empty?
-
-      false
-    end
-
     def alt_for(key, segment)
       return segment unless key
       return segment unless alts[key]
@@ -63,12 +42,23 @@ module Eunomia
     end
 
     def generate(request)
-      result = Eunomia::Result.new(key, value: value)
+      result = Eunomia::Result.new(key, value:)
       segments.each { |seg| result.append(seg.generate(request)) }
-      result.apply(alts, functions, locale: request.alt_key)
+      result.apply(alts, functions, locale: request.locale)
       result.merge_meta(meta)
-      result.add_tags_as_meta(tags)
       result
     end
+
+    def to_h
+      hsh = {
+        segments: segments.map(&:to_s).join,
+        weight:
+      }
+
+      hsh[:value] = value if value != 0
+      hsh[:meta] = meta unless meta.empty?
+      hsh[:functinos] = functions unless functions.empty?
+      hsh
+    end
   end
 end

data/lib/eunomia/request.rb

@@ -1,31 +1,24 @@
 # frozen_string_literal: true
 
 module Eunomia
-  class Request
-    attr_reader :key, :alt_key, :alts, :meta, :tags, :functions, :constants, :depth
-
-    def initialize(key, alts: {}, alt_key: nil, meta: {}, tags: [], functions: [], constants: {}, unique: false)
-      @key = key
-      @alt_key = alt_key
-      @alts = alts || {}
-      @meta = meta || {}
-      @tags = Set.new(tags || [])
-      @constants = constants || {}
-      @functions = functions || []
-      @depth = 0
-      @unique = unique ? Set.new : nil
-    end
+  # Encapsuate a request for string generation
+  class Request < Eunomia::Generator
+    # If not nil, a set of value strings; this is
+    # Persisted across calls to generate
+    attr_reader :unique
 
-    def generate_unique?
-      !@unique.nil?
-    end
+    # If given, alts are chosen from the given locale key
+    attr_reader :locale
 
-    def alt_key?
-      !alt_key.nil?
-    end
+    # The current depth (calls to generate) for the run
+    attr_reader :depth
 
-    def alt_for(segment)
-      alts[segment] || segment
+    def initialize(key, alts: {}, locale: nil, constants: {}, filters: [], functions: [], unique: false)
+      hsh = { key:, items: ["request"], alts:, constants:, filters:, gen: "sequence", functions: }
+      @unique = unique ? Set.new : nil
+      @depth = 0
+      @locale = locale
+      super(hsh)
     end
 
     def increase_depth
@@ -40,10 +33,10 @@ module Eunomia
       100.times do
         result = gen.generate(self)
         result.apply(alts, functions)
-        return result if !@unique || @unique.add?(result.to_s)
+        return result if passes_filters?(result) && (!unique || unique.add?(result.to_s))
       end
 
-      raise "Unable to find a unique result"
+      raise "Unable to find a unique result that passes filters"
     end
   end
 end

data/lib/eunomia/result.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Eunomia
+  # A generated result
   class Result
     attr_reader :key, :display, :elements, :multiplier, :base_value, :meta
 
@@ -9,16 +10,17 @@ module Eunomia
       @base_value = value
       @multiplier = multiplier
       @elements = []
-      @meta = Hash.new {|h,k| h[k] = Set.new}
+      @meta = Hash.new { |h, k| h[k] = Set.new }
       @display = ""
     end
 
     def append(obj)
-      if obj.is_a?(Element)
+      case obj
+      when Element
         append_element(obj)
-      elsif obj.is_a?(Result)
+      when Result
         append_result(obj)
-      elsif obj.is_a?(Separator)
+      when Separator
         append_separator(obj)
       end
     end
@@ -55,19 +57,11 @@ module Eunomia
       end
     end
 
-    def add_tags_as_meta(tags)
-      tags.each do |tag|
-        arr = tag.split(':')
-        @meta[arr[0]] << arr[1].gsub("-", " ") if arr.length > 1
-      end
-    end
-
-
     def apply_translations(alts, locale: nil)
       arr = to_s.split(/\s+/)
-      arr = arr.map do |segment|
+      arr.map do |segment|
         hsh = alts[segment]
-        hsh = hsh.is_a?(Hash) ? hsh[locale] || hsh['*'] || segment : hsh || segment
+        hsh.is_a?(Hash) ? hsh[locale] || hsh["*"] || segment : hsh || segment
       end
     end
 
@@ -76,10 +70,10 @@ module Eunomia
     end
 
     def apply(alts, functions, locale: nil)
-      arr = apply_translations(alts, locale: locale)
+      arr = apply_translations(alts, locale:)
       arr = apply_functions(arr, functions)
 
-      @display = arr.join(' ')
+      @display = arr.join(" ")
       self
     end
 

data/lib/eunomia/segment/common.rb

@@ -14,7 +14,11 @@ module Eunomia
 
       def generate(_request)
         calc # update values for dynamic segments
-        Eunomia::Element.new(text, value: value, multiplier: multiplier)
+        Eunomia::Element.new(text, value:, multiplier:)
+      end
+
+      def meta_keys
+        Set.new
       end
 
       def calc; end

data/lib/eunomia/segment/constant.rb

@@ -2,10 +2,11 @@
 
 module Eunomia
   module Segment
+    # Represents a constant in a segment.
     class Constant
       include Common
 
-      SEPARATOR_MATCHER = /\p{Space}|\p{Punct}/
+      SEPARATOR_MATCHER = /\p{Space}|\p{Punct}|[+]/
 
       attr_reader :text
 
@@ -14,10 +15,14 @@ module Eunomia
       end
 
       def generate(_request)
-        calc # update values for dynamic segments
+        # calc # update values for dynamic segments
         Eunomia::Separator.new(text)
       end
 
+      def to_s
+        text
+      end
+
       def self.build(scanner)
         str = scanner.scan(SEPARATOR_MATCHER)
         new(str) if str

data/lib/eunomia/segment/dice.rb

@@ -54,6 +54,10 @@ module Eunomia
         @multiplier ||= calc
       end
 
+      def to_s
+        "#{count}d#{range}#{opp}#{constant}"
+      end
+
       def self.build(scanner)
         str = scanner.scan(DICE_MATCHER)
         return unless str

data/lib/eunomia/segment/number.rb

@@ -2,10 +2,12 @@
 
 module Eunomia
   module Segment
+    # Represents a number in a segment. The value
+    # is the multiplier for the item.
     class Number
       include Common
 
-      NUMBER_MATCHER = /(\d+)/
+      NUMBER_MATCHER = /([+-]?\d+)/
 
       attr_reader :text, :multipler
 
@@ -14,6 +16,10 @@ module Eunomia
         @text = number.to_s
       end
 
+      def to_s
+        text
+      end
+
       def self.build(scanner)
         str = scanner.scan(NUMBER_MATCHER)
         new(str) if str

data/lib/eunomia/segment/reference.rb

@@ -30,8 +30,8 @@ module Eunomia
         @generator ||= Eunomia.lookup(key)
       end
 
-      def item_tags
-        generator.item_tags
+      def meta_keys
+        generator.meta_keys
       end
 
       def generate(request)
@@ -45,6 +45,10 @@ module Eunomia
         @lookup ||= label.nil? ? key : "#{key}:#{label}"
       end
 
+      def to_s
+        "[#{lookup}]"
+      end
+
       def self.build(scanner)
         str = scanner.scan(REFERENCE_MATCHER)
         return unless str

data/lib/eunomia/segment/text.rb

@@ -14,6 +14,10 @@ module Eunomia
         @text = text
       end
 
+      def to_s
+        text
+      end
+
       def self.build(scanner)
         str = scanner.scan(TEXT_MATCHER)
         new(str) if str

data/lib/eunomia/segment.rb

@@ -10,6 +10,8 @@ require_relative "segment/number"
 require_relative "segment/reference"
 
 module Eunomia
+  class EunomiaParseError < StandardError; end
+
   # Segment represents a single token in an `Item`.
   module Segment
     def self.build(str)
@@ -21,7 +23,7 @@ module Eunomia
               Eunomia::Segment::Number.build(ss) ||
               Eunomia::Segment::Text.build(ss) ||
               Eunomia::Segment::Constant.build(ss)
-        raise "Unable to parse #{ss.rest} (#{ss.rest_size})" unless seg
+        raise EunomiaParseError, "Unable to parse #{ss.rest} (#{ss.rest_size})" unless seg
 
         arr << seg
       end

data/lib/eunomia/selector.rb

@@ -39,6 +39,14 @@ module Eunomia
       nil
     end
 
+    def sequence(items)
+      # Weights for a sequence are the chance of not appearing in the
+      # result
+      items.select do |item|
+        item.weight <= count.nil? ? rand(1..100) : roll
+      end
+    end
+
     def random(items)
       max_weight = items.map(&:weight).sum
       if count.nil? || count >= max_weight
@@ -50,10 +58,13 @@ module Eunomia
       end
     end
 
+    # zero-index roll of dice (e.g. 3d6 => 0..15)
     def roll
-      sum = 0
-      count.times { sum += rand(range) }
-      sum
+      (1..count).inject(0) { |sum, _| sum + rand(range) }
+    end
+
+    def to_s
+      count ? "#{count}d#{range}" : "random"
     end
   end
 end

data/lib/eunomia/separator.rb

@@ -13,7 +13,7 @@ module Eunomia
     end
 
     def to_h
-      { orig: text, text: text }
+      { orig: text, text: }
     end
   end
 end

data/lib/eunomia/store.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Eunomia
+  class EunomiaKeyNotFoundError < StandardError; end
+
   # Store holds all the generators. Generators are stored by key.
   class Store
     def initialize
@@ -8,7 +10,7 @@ module Eunomia
     end
 
     def lookup(key)
-      @generators[key] or raise Error, "Generator #{key} not found"
+      @generators[key] or raise EunomiaKeyNotFoundError, "Generator #{key} not found"
     end
 
     def keys
@@ -31,9 +33,7 @@ module Eunomia
       else
         gen = Eunomia::Generator.new(hsh_or_array)
         @generators[gen.key] = gen
-        gen.aliases.each do |alias_key|
-          @generators[alias_key] = gen
-        end
+        gen
       end
     end
   end

data/lib/eunomia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eunomia
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

data/lib/eunomia.rb

@@ -13,42 +13,41 @@ require_relative "eunomia/result"
 require_relative "eunomia/segment"
 require_relative "eunomia/functions"
 
+# A random data generator
 module Eunomia
-  class Error < StandardError; end
-
-  @@functions = Functions.new
-  @@generators = Store.new
+  @functions = Functions.new
+  @generators = Store.new
 
   def self.lookup(key)
-    @@generators.lookup(key)
+    @generators.lookup(key)
   end
 
   def self.generate(key, request = nil)
-    request = Request.new(key) unless request
-    @@generators.lookup(key).generate(request)
+    request ||= Request.new(key)
+    @generators.lookup(key).generate(request)
   end
 
   def self.read(path)
-    @@generators.read(path)
+    @generators.read(path)
   end
 
   def self.add(hsh_or_array)
-    @@generators.add(hsh_or_array)
+    @generators.add(hsh_or_array)
   end
 
   def self.add_function(name, function)
-    @@functions.add(name, function)
+    @functions.add(name, function)
   end
 
   def self.keys
-    @@generators.keys
+    @generators.keys
   end
 
-  def self.request(key, alts: {}, alt_key: nil, meta: {}, tags: [], functions: [], constants: {}, unique: false)
-    Request.new(key, alts:, alt_key:, meta:, tags:, functions:, constants:, unique:)
+  def self.request(key, alts: {}, locale: nil, filters: [], functions: [], constants: {}, unique: false)
+    Request.new(key, alts:, locale:, filters:, functions:, constants:, unique:)
   end
 
   def self.apply(arr, functions)
-    @@functions.apply(arr, functions)
+    @functions.apply(arr, functions)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eunomia_gen
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - G Palmer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-17 00:00:00.000000000 Z
+date: 2025-10-07 00:00:00.000000000 Z
 dependencies: []
 description: Create random string with a focus on RPGs similar to fantasynamegenerators.com
 email:
@@ -20,6 +20,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".zed/settings.json"
 - ".zed/tasks.json"
 - CHANGELOG.md
@@ -71,14 +72,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Generate random strings from a hash specification