eunomia_gen 0.1.0

data/lib/eunomia/generator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Eunomia
+  # Generator consists of a list of Items. When generating a result,
+  # an item is selected at random based on the item's weight.
+  class Generator
+    include Eunomia::HashHelpers
+
+    attr_reader :key,
+                :alts,
+                :meta,
+                :functions,
+                :tags,
+                :items,
+                :selector,
+                :sep
+
+    def initialize(hsh)
+      @key = field_or_raise(hsh, :key)
+      @functions = list_field(hsh, :functions)
+      @alts = hash_field(hsh, :alts)
+      @meta = meta_field(hsh)
+      @tags = tags_field(hsh)
+      @selector = Eunomia::Selector.new(field_or_nil(hsh, :rng))
+      @items = items_from(hsh)
+      raise "Generators must have items" if @items.empty?
+    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 alt_for(key, segment)
+      return segment unless key
+      return segment unless alts[key]
+
+      alts[key][segment] || segment
+    end
+
+    # Select items that have all the given tag values
+    def filter(tags)
+      return items if tags.empty?
+
+      items.select { |item| (tags - item.tags).empty? }
+    end
+
+    def generate(request)
+      items = filter(request.tags)
+      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
+    end
+  end
+end

data/lib/eunomia/hash_helpers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module HashHelpers
+    def field_or_nil(hsh, key)
+      hsh[key.to_sym] || hsh[key.to_s]
+    end
+
+    def field_or_raise(hsh, key)
+      val = field_or_nil(hsh, key)
+      raise "Missing key: #{key}" unless val
+
+      val
+    end
+
+    def int_field(hsh, key, default = 0)
+      n = field_or_nil(hsh, key)
+      n.nil? ? default : n.to_i
+    end
+
+    def list_field(hsh, key)
+      field = field_or_nil(hsh, key)
+      return [] unless field
+
+      field.is_a?(String) ? field.split(/\s+/) : field
+    end
+
+    def tags_field(hsh)
+      tags = list_field(hsh, :tags)
+      return Set.new unless tags
+
+      Set.new(tags)
+    end
+
+    def alts_field(hsh)
+      hash_field(hsh, :alts)
+    end
+
+    def meta_field(hsh)
+      hash_field(hsh, :meta)
+    end
+
+    def hash_field(hsh, key)
+      field = field_or_nil(hsh, key)
+      return {} unless field
+
+      field.is_a?(Hash) ? field : {}
+    end
+  end
+end

data/lib/eunomia/item.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Eunomia
+  class Item
+    include Eunomia::HashHelpers
+
+    attr_reader :key,
+                :weight,
+                :value,
+                :tags,
+                :alts,
+                :meta,
+                :functions,
+                :segments
+
+    def initialize(key, hsh, add_tags = nil)
+      @key = key
+      @weight = int_field(hsh, :weight).clamp(1, 1000)
+      @value = int_field(hsh, :value).clamp(0, 1_000_000)
+      @tags = tags_field(hsh)
+      @tags += add_tags if add_tags
+      @alts = alts_field(hsh)
+      @meta = meta_field(hsh)
+      @functions = list_field(hsh, :functions)
+      @segments = scan(field_or_raise(hsh, :segments)).flatten
+      raise "Items must have segments" if @segments.empty?
+    end
+
+    def scan(obj)
+      return [] if obj.nil?
+      return Eunomia::Segment.build(obj.to_s) unless obj.is_a?(Array)
+
+      obj.map { |e| Eunomia::Segment.build(e) }.flatten
+    end
+
+    def alt_for(key, segment)
+      return segment unless key
+      return segment unless alts[key]
+
+      alts[key][segment] || segment
+    end
+
+    def generate(request)
+      result = Eunomia::Result.new(key, value: value)
+      segments.each { |seg| result.append(seg.generate(request)) }
+      result.apply(alts, functions, locale: request.alt_key)
+      result.merge_meta(meta)
+      result
+    end
+  end
+end

data/lib/eunomia/request.rb

@@ -0,0 +1,49 @@
+# 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
+
+    def generate_unique?
+      !@unique.nil?
+    end
+
+    def alt_key?
+      !alt_key.nil?
+    end
+
+    def alt_for(segment)
+      alts[segment] || segment
+    end
+
+    def increase_depth
+      @depth += 1
+      raise "Depth exceeded" if @depth > 100
+    end
+
+    def generate
+      @depth = 0
+      gen = Eunomia.lookup(key)
+
+      100.times do
+        result = gen.generate(self)
+        result.apply(alts, functions)
+        return result if !@unique || @unique.add?(result.to_s)
+      end
+
+      raise "Unable to find a unique result"
+    end
+  end
+end

data/lib/eunomia/result.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Eunomia
+  class Result
+    attr_reader :key, :display, :elements, :multiplier, :base_value, :meta
+
+    def initialize(key, value: 0, multiplier: 1)
+      @key = key
+      @base_value = value
+      @multiplier = multiplier
+      @elements = []
+      @meta = Hash.new {|h,k| h[k] = Set.new}
+      @display = ""
+    end
+
+    def append(obj)
+      if obj.is_a?(Element)
+        append_element(obj)
+      elsif obj.is_a?(Result)
+        append_result(obj)
+      elsif obj.is_a?(Separator)
+        append_separator(obj)
+      end
+    end
+
+    def append_element(element)
+      @elements << element
+      @display += element.to_s
+      @multiplier *= element.multiplier unless element.multiplier.nil?
+      @base_value += element.value unless element.value.nil?
+      merge_meta(element.meta)
+      self
+    end
+
+    def append_separator(separator)
+      @display += separator.to_s
+      self
+    end
+
+    def append_result(result)
+      element = Element.new(result.to_s, value: result.value, multiplier: result.multiplier, children: result.elements)
+      @elements << element
+      @display += element.to_s
+      @base_value += element.value
+      merge_meta(result.meta)
+      self
+    end
+
+    def merge_meta(m)
+      return unless m
+
+      m.each do |k, v|
+        v = [v] unless v.is_a?(Enumerable)
+        @meta[k] = Set.new(@meta[k] + v).to_a
+      end
+    end
+
+    def apply_translations(alts, locale: nil)
+      arr = to_s.split(/\s+/)
+      arr = arr.map do |segment|
+        hsh = alts[segment]
+        hsh = hsh.is_a?(Hash) ? hsh[locale] || hsh['*'] || segment : hsh || segment
+      end
+    end
+
+    def apply_functions(arr, functions)
+      Eunomia.apply(arr, functions)
+    end
+
+    def apply(alts, functions, locale: nil)
+      arr = apply_translations(alts, locale: locale)
+      arr = apply_functions(arr, functions)
+
+      @display = arr.join(' ')
+      self
+    end
+
+    def value
+      base_value * multiplier
+    end
+
+    def to_s
+      @display
+    end
+
+    def to_h
+      { display:, key:, value:, multiplier:, meta:, elements: elements&.map(&:to_h) }
+    end
+  end
+end

data/lib/eunomia/segment/common.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    # Common implementations of the value, multiplier, calc and generate methods
+    module Common
+      def value
+        0
+      end
+
+      def multiplier
+        1
+      end
+
+      def generate(_request)
+        calc # update values for dynamic segments
+        Eunomia::Element.new(text, value: value, multiplier: multiplier)
+      end
+
+      def calc; end
+    end
+  end
+end

data/lib/eunomia/segment/constant.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    class Constant
+      include Common
+
+      SEPARATOR_MATCHER = /\p{Space}|\p{Punct}/
+
+      attr_reader :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def generate(_request)
+        calc # update values for dynamic segments
+        Eunomia::Separator.new(text)
+      end
+
+      def self.build(scanner)
+        str = scanner.scan(SEPARATOR_MATCHER)
+        new(str) if str
+      end
+    end
+  end
+end

data/lib/eunomia/segment/dice.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    # Dice generates a random number using dice notation (e.g. `[3d6]`)
+    # with common operators (e.g. `[3d6+2]` or `[4d10x2]`)
+    # All values are integers so using the division operator
+    # will be rounded down.
+    class Dice
+      include Common
+
+      DICE_MATCHER = %r{\[(\d+)?d(\d+)(?:([+x/-])(\d+))?\]}
+      ADD = "+"
+      MULTIPLY = "x"
+      SUBTRACT = "-"
+      DIVIDE = "/"
+      OPS = [ADD, MULTIPLY, SUBTRACT, DIVIDE].freeze
+
+      attr_reader :count, :range, :op, :constant
+
+      def initialize(count, range, op = ADD, constant = 0)
+        @count = count.to_i.clamp(1, 100)
+        @range = range.to_i.clamp(1, 1_000_000)
+        @op = OPS.include?(op) ? op : ADD
+        @constant = constant.to_i.clamp(0, 1_000_000)
+      end
+
+      def roll
+        @multiplier = nil
+        sum = 0
+        count.times { sum += (rand(range) + 1) }
+        sum
+      end
+
+      def calc
+        case op
+        when MULTIPLY
+          roll * constant
+        when DIVIDE
+          roll / constant
+        when SUBTRACT
+          roll - constant
+        when ADD
+          roll + constant
+        end
+      end
+
+      def text
+        @multiplier ||= calc
+        @multiplier.to_s
+      end
+
+      def multiplier
+        @multiplier ||= calc
+      end
+
+      def self.build(scanner)
+        str = scanner.scan(DICE_MATCHER)
+        return unless str
+
+        new(scanner[1], scanner[2], scanner[3], scanner[4])
+      end
+    end
+  end
+end

data/lib/eunomia/segment/number.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    class Number
+      include Common
+
+      NUMBER_MATCHER = /(\d+)/
+
+      attr_reader :text, :multipler
+
+      def initialize(number)
+        @multiplier = number.to_i
+        @text = number.to_s
+      end
+
+      def self.build(scanner)
+        str = scanner.scan(NUMBER_MATCHER)
+        new(str) if str
+      end
+    end
+  end
+end

data/lib/eunomia/segment/reference.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    # Reference represents a link to a Generator defined with square brackets.
+    # A request may define a constant that is used in place of a generator to
+    # return a specific value. This can be identified with a label so that the
+    # substitution is only used in specific context. For example `[test]` would
+    # first look for a constant named `test` and if not found, get the generator
+    # from the store. `[test:label]` would only use the constant if the request
+    # has a constant key if `test:label` and, otherwise, use the generator
+    # called `test`.
+    class Reference
+      include Common
+
+      REFERENCE_MATCHER = /^\[([A-Za-z][A-Za-z0-9_-]+)(?::([A-Za-z0-9_-]+))?\]/
+
+      attr_reader :key, :label
+
+      def initialize(key, label = nil)
+        @key = key
+        @label = label
+      end
+
+      def label?
+        !label.nil?
+      end
+
+      def generate(request)
+        return Eunomia::Element.new(request.constants[lookup]) if request.constants.key?(lookup)
+
+        request.increase_depth
+        Eunomia.generate(key, request)
+      end
+
+      def lookup
+        @lookup ||= label.nil? ? key : "#{key}:#{label}"
+      end
+
+      def self.build(scanner)
+        str = scanner.scan(REFERENCE_MATCHER)
+        return unless str
+
+        new(scanner[1], scanner[2])
+      end
+    end
+  end
+end

data/lib/eunomia/segment/text.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Eunomia
+  module Segment
+    # Text respresents a string of constant, non-numeric text.
+    class Text
+      include Common
+
+      TEXT_MATCHER = /\p{Alpha}[\p{Alnum}-]*/
+
+      attr_reader :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def self.build(scanner)
+        str = scanner.scan(TEXT_MATCHER)
+        new(str) if str
+      end
+    end
+  end
+end

data/lib/eunomia/segment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+require_relative "segment/common"
+require_relative "segment/dice"
+require_relative "segment/constant"
+require_relative "segment/text"
+require_relative "segment/number"
+require_relative "segment/reference"
+
+module Eunomia
+  # Segment represents a single token in an `Item`.
+  module Segment
+    def self.build(str)
+      ss = StringScanner.new(str)
+      arr = []
+      until ss.eos?
+        seg = Eunomia::Segment::Dice.build(ss) ||
+              Eunomia::Segment::Reference.build(ss) ||
+              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
+
+        arr << seg
+      end
+      arr
+    end
+  end
+end

data/lib/eunomia/selector.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Eunomia
+  # Selector defines a strategy for selecting an item from a list of items.
+  # The default behavior is to randomly generate a number between 0 and the
+  # sum of the weights of the items and select the first match.
+  #
+  # Alternately, a dice notation string can be provided to generate a random
+  # number based on the dice notation. The dice notation is shifted down based
+  # on the number of dice so that, for example, 2d6 will generate a number
+  # between 0 and 10.
+  #
+  # If the dice notation is less than the total weight of the items the
+  # items greater than the maxumum value are ignored. If the dice notation is
+  # greater than the total weight of the items the number is regenerated.
+  class Selector
+    DICE_MATCHER = /^(\d+)?d(\d+)?/
+
+    attr_reader :count, :range
+
+    def initialize(dice = nil)
+      @count = nil
+      @range = nil
+      return unless dice
+
+      m = DICE_MATCHER.match(dice)
+      return unless m
+
+      @count = m[1].to_i.clamp(1, 100)
+      @range = m[2].to_i.clamp(1, 10_000)
+    end
+
+    def select(items)
+      n = random(items)
+      items.each do |item|
+        n -= item.weight
+        return item if n.negative?
+      end
+      nil
+    end
+
+    def random(items)
+      max_weight = items.map(&:weight).sum
+      if count.nil? || count >= max_weight
+        rand(max_weight)
+      else
+        n = roll
+        n /= 2 while n >= max_weight
+        n
+      end
+    end
+
+    def roll
+      sum = 0
+      count.times { sum += rand(range) }
+      sum
+    end
+  end
+end

data/lib/eunomia/separator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Eunomia
+  class Separator
+    attr_reader :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_s
+      text
+    end
+
+    def to_h
+      { orig: text, text: text }
+    end
+  end
+end

data/lib/eunomia/store.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Eunomia
+  # Store holds all the generators. Generators are stored by key.
+  class Store
+    def initialize
+      @generators = {}
+    end
+
+    def lookup(key)
+      @generators[key] or raise Error, "Generator #{key} not found"
+    end
+
+    def keys
+      @generators.keys
+    end
+
+    def read(path)
+      text = File.read(path)
+      hsh_or_array = JSON.parse(text)
+      add(hsh_or_array)
+    end
+
+    def add(hsh_or_array)
+      return unless hsh_or_array
+
+      if hsh_or_array.is_a?(Array)
+        hsh_or_array.each do |item|
+          add(item)
+        end
+      else
+        gen = Eunomia::Generator.new(hsh_or_array)
+        @generators[gen.key] = gen
+      end
+    end
+  end
+end

data/lib/eunomia/version.rb

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