zer0-image-generator 0.6.0 → 0.8.0

data/lib/zer0_image_generator/settings.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+# Port of the settings layer of lib/zer0_image_generator/preview_generator.py:
+# the Settings value object, resolve_settings' CLI>env>config>DEFAULTS
+# precedence chain, and the per-file override machinery (author + collection
+# style blocks). The Python file stays the oracle;
+# test/ruby/test_settings.rb differential-tests resolve_settings against it.
+
+require_relative "config"
+
+module Zer0ImageGenerator
+  # Fully-resolved run settings (before per-file author overrides).
+  #
+  # Ports the Python `@dataclass Settings`. Field names and defaults match the
+  # oracle one-for-one so `to_h` diffs cleanly against `dataclasses.asdict`.
+  class Settings
+    ATTRIBUTES = %i[
+      provider model size quality style style_modifiers output_dir
+      assets_prefix auto_prefix enabled collections collections_dir
+      collection_styles front_matter_key authors_file prompt_engine
+      review_engine claude_model claude_effort dry_run verbose force
+      list_only parallel batch file collection enhance enhance_prompt
+      enhance_model enhance_quality enhance_fidelity enhance_format
+      rasterizer provider_explicit
+    ].freeze
+
+    attr_accessor(*ATTRIBUTES)
+
+    def initialize(**overrides)
+      @provider = DEFAULTS["provider"]
+      @model = DEFAULTS["model"]
+      @size = DEFAULTS["size"]
+      @quality = DEFAULTS["quality"]
+      @style = DEFAULTS["style"]
+      @style_modifiers = DEFAULTS["style_modifiers"]
+      @output_dir = DEFAULTS["output_dir"]
+      @assets_prefix = DEFAULTS["assets_prefix"]
+      @auto_prefix = DEFAULTS["auto_prefix"]
+      @enabled = true
+      # Fresh copies so two Settings never share the same mutable default
+      # (mirrors the dataclass field(default_factory=...)).
+      @collections = DEFAULTS["collections"].dup
+      @collections_dir = DEFAULTS["collections_dir"]
+      @collection_styles = {}
+      @front_matter_key = DEFAULTS["front_matter_key"]
+      @authors_file = DEFAULTS["authors_file"]
+      @prompt_engine = DEFAULTS["prompt_engine"]
+      @review_engine = DEFAULTS["review_engine"]
+      @claude_model = DEFAULTS["claude_model"]
+      @claude_effort = DEFAULTS["claude_effort"]
+
+      @dry_run = false
+      @verbose = false
+      @force = false
+      @list_only = false
+      @parallel = 4
+      @batch = 0
+
+      @file = ""
+      @collection = ""
+
+      @enhance = false
+      @enhance_prompt = ""
+      @enhance_model = ENHANCE_DEFAULTS["model"]
+      @enhance_quality = ENHANCE_DEFAULTS["quality"]
+      @enhance_fidelity = ENHANCE_DEFAULTS["fidelity"]
+      @enhance_format = ENHANCE_DEFAULTS["format"]
+
+      @rasterizer = "auto"
+      @provider_explicit = false
+
+      overrides.each { |key, value| public_send("#{key}=", value) }
+    end
+
+    def to_h
+      ATTRIBUTES.each_with_object({}) { |attr, acc| acc[attr] = public_send(attr) }
+    end
+
+    # Port of dataclasses.replace(settings, **changes): a copy with `changes`
+    # applied. Accepts string or symbol keys (OVERRIDE_KEYS are strings).
+    def dup_with(changes)
+      copy = dup
+      copy.instance_variable_set(:@collections, @collections.dup)
+      copy.instance_variable_set(:@collection_styles, @collection_styles.dup)
+      changes.each { |key, value| copy.public_send("#{key}=", value) }
+      copy
+    end
+
+    def ==(other)
+      other.is_a?(Settings) && to_h == other.to_h
+    end
+  end
+
+  # Mirrors the argparse.Namespace resolve_settings consumes. A CLI builds one
+  # from parsed flags; a Rails controller builds one from request params. Field
+  # names and defaults match build_arg_parser's `dest=` / `default=`.
+  #
+  # Build with a Hash (string or symbol keys); `Args.build` applies argparse
+  # defaults for anything omitted and reproduces parse_args' post-processing
+  # (the historical rule that --enhance-prompt / -fidelity / -format imply
+  # --enhance) so a Rails caller behaves identically to the CLI.
+  class Args
+    DEFAULTS = {
+      dry_run: false, verbose: false, file: nil, collection: nil,
+      provider: nil, model: nil, output_dir: nil, force: false,
+      list_missing: false, parallel: nil, enhance: false,
+      enhance_prompt: nil, enhance_model: nil, enhance_quality: nil,
+      enhance_fidelity: nil, enhance_format: nil, prompt_engine: nil,
+      review: nil, rasterizer: nil, style: nil, assets_prefix: nil,
+      no_auto_prefix: false, collections_dir: nil, front_matter_key: nil,
+      authors_file: nil, batch: 0, log_file: nil, rate_limit: nil
+    }.freeze
+
+    attr_accessor(*DEFAULTS.keys)
+
+    def self.build(source = {})
+      return source if source.is_a?(Args)
+
+      normalized = {}
+      (source.respond_to?(:to_h) ? source.to_h : source).each do |key, value|
+        normalized[key.to_sym] = value
+      end
+      new(normalized).tap(&:apply_enhance_implication!)
+    end
+
+    def initialize(overrides = {})
+      DEFAULTS.each { |key, value| instance_variable_set("@#{key}", value) }
+      overrides.each do |key, value|
+        sym = key.to_sym
+        # Unknown keys would silently vanish; surface them instead of masking a
+        # caller typo (e.g. :front_matter vs :front_matter_key).
+        raise ArgumentError, "unknown Args field: #{key}" unless DEFAULTS.key?(sym)
+
+        instance_variable_set("@#{sym}", value)
+      end
+    end
+
+    # parse_args post-processing: these three flags imply --enhance, but
+    # --enhance-model deliberately does not (historical behavior).
+    def apply_enhance_implication!
+      @enhance = true if @enhance_prompt || @enhance_fidelity || @enhance_format
+      self
+    end
+  end
+
+  module_function
+
+  # Settings fields an override block may replace per file (see constants.rb's
+  # OVERRIDE_KEYS). Keep only recognized keys with non-empty stringified values.
+  def _filter_override_block(block)
+    return {} unless block.is_a?(Hash)
+
+    result = {}
+    block.each do |key, value|
+      next unless OVERRIDE_KEYS.include?(key)
+      next if value.nil?
+
+      # python_str, not to_s: a boolean override value must stringify as
+      # "True"/"False" (CPython str()) to stay byte-identical to the oracle.
+      stripped = python_str(value).strip
+      result[key] = stripped unless stripped.empty?
+    end
+    result
+  end
+
+  # `preview:` override block for an author key. `author:` may be a list or
+  # mapping in some posts — only a plain string key can index authors.yml.
+  def author_preview_overrides(authors, author_key)
+    return {} unless author_key.is_a?(String) && !author_key.empty?
+
+    author = authors[author_key]
+    return {} unless author.is_a?(Hash)
+
+    _filter_override_block(author["preview"])
+  end
+
+  # The file's collection, from the nearest `_<name>` ancestor directory
+  # (Jekyll's collection layout) — "" for files outside any collection.
+  def collection_of(path)
+    Pathname.new(path.to_s).expand_path.parent.ascend do |ancestor|
+      name = ancestor.basename.to_s
+      return name[1..] if name.start_with?("_") && name.length > 1
+    end
+    ""
+  end
+
+  # The file's section — the directory immediately INSIDE its collection
+  # (`pages/_posts/hacks/x.md` -> 'hacks') — or "" when the collection holds its
+  # files flat. Sites that fold several kinds of writing into one collection
+  # carry the editorial distinction here, and it is the strongest single signal
+  # for what a banner should look like.
+  def section_of(path)
+    parts = Pathname.new(path.to_s).expand_path.to_s.split(File::SEPARATOR)
+    parts.each_with_index do |name, i|
+      next unless name.start_with?("_") && name.length > 1
+
+      # parts[i + 1] is a directory only when something follows it.
+      return i + 2 < parts.length ? parts[i + 1] : ""
+    end
+    ""
+  end
+
+  # The page context the local renderer derives its art from.
+  def article_art_context(content_file, slug)
+    {
+      "slug" => slug,
+      "section" => (s = section_of(content_file.path)).empty? ? collection_of(content_file.path) : s,
+      "title" => content_file.title.to_s,
+      "description" => content_file.description.to_s,
+      "categories" => content_file.categories.to_s,
+      "body" => content_file.content.to_s,
+    }
+  end
+
+  # `collection_styles:` override block for a collection — same keys as author
+  # overrides, so each collection can carry its own visual theme.
+  def collection_preview_overrides(collection_styles, collection)
+    return {} if collection.nil? || collection.empty? || !collection_styles.is_a?(Hash)
+
+    _filter_override_block(collection_styles[collection])
+  end
+
+  # Merge CLI > env > _config.yml `preview_images:` > DEFAULTS into a Settings.
+  # `config` is the site's FULL _config.yml Hash — the block is extracted here,
+  # and two top-level Jekyll keys are honored as fallbacks: collections_dir and
+  # (for `collections: auto`) the collections: map.
+  #
+  # `args` is an Args (or any Hash/Struct Args.build accepts).
+  def resolve_settings(args, config)
+    args = Args.build(args)
+
+    site = config["preview_images"]
+    site = {} unless site.is_a?(Hash)
+
+    cfg = lambda do |key, default|
+      value = site[key]
+      value.nil? ? default : value
+    end
+
+    # env only wins when the CLI value is nil AND the env value is non-empty.
+    pick = lambda do |cli_value, env_name, cfg_key|
+      return cli_value unless cli_value.nil?
+
+      env_value = ENV[env_name]
+      return env_value if !env_value.nil? && !env_value.empty?
+
+      python_str(cfg.call(cfg_key, DEFAULTS[cfg_key]))
+    end
+
+    # collections_dir: block override > Jekyll's own top-level key > default.
+    collections_dir = cfg.call(
+      "collections_dir",
+      python_first_truthy(config["collections_dir"], DEFAULTS["collections_dir"])
+    )
+    collections_dir = args.collections_dir unless args.collections_dir.nil?
+
+    collections = cfg.call("collections", DEFAULTS["collections"])
+    if collections == "auto" || (collections.is_a?(Array) && collections.include?("auto"))
+      # Discover from Jekyll's own collections: map; posts always exists.
+      declared = config["collections"]
+      names = declared.is_a?(Hash) ? declared.keys : []
+      collections = ["posts"] + names.reject { |n| n == "posts" }
+    end
+    collections = DEFAULTS["collections"].dup unless collections.is_a?(Array) && !collections.empty?
+
+    parallel_env = ENV.fetch("MAX_PARALLEL", "")
+    parallel = if !args.parallel.nil?
+                 args.parallel
+               elsif parallel_env.match?(/\A[0-9]+\z/)
+                 Integer(parallel_env, 10)
+               else
+                 4
+               end
+
+    collection_styles = cfg.call("collection_styles", {})
+    collection_styles = {} unless collection_styles.is_a?(Hash)
+
+    Settings.new(
+      provider: pick.call(args.provider, "AI_PROVIDER", "provider"),
+      model: pick.call(args.model, "IMAGE_MODEL", "model"),
+      size: pick.call(nil, "IMAGE_SIZE", "size"),
+      quality: pick.call(nil, "IMAGE_QUALITY", "quality"),
+      style: pick.call(args.style, "IMAGE_STYLE", "style"),
+      style_modifiers: pick.call(nil, "IMAGE_STYLE_MODIFIERS", "style_modifiers"),
+      output_dir: pick.call(args.output_dir, "OUTPUT_DIR", "output_dir"),
+      assets_prefix: (
+        args.assets_prefix.nil? ? python_str(cfg.call("assets_prefix", DEFAULTS["assets_prefix"])) : args.assets_prefix
+      ),
+      auto_prefix: (
+        args.no_auto_prefix ? false : python_bool(cfg.call("auto_prefix", DEFAULTS["auto_prefix"]))
+      ),
+      enabled: python_bool(cfg.call("enabled", true)),
+      collections: collections.map { |c| python_str(c) },
+      collection_styles: collection_styles,
+      collections_dir: python_str(python_first_truthy(collections_dir, "")).strip.gsub(%r{\A/+|/+\z}, ""),
+      front_matter_key: python_first_truthy(
+        args.front_matter_key,
+        python_str(cfg.call("front_matter_key", DEFAULTS["front_matter_key"])).strip,
+        DEFAULTS["front_matter_key"]
+      ),
+      authors_file: (
+        if args.authors_file.nil?
+          python_str(python_first_truthy(cfg.call("authors_file", DEFAULTS["authors_file"]), ""))
+        else
+          args.authors_file
+        end
+      ),
+      prompt_engine: pick.call(args.prompt_engine, "PROMPT_ENGINE", "prompt_engine"),
+      review_engine: pick.call(args.review, "REVIEW_ENGINE", "review_engine"),
+      claude_model: python_str(python_first_truthy(cfg.call("claude_model", ""), "")),
+      claude_effort: python_str(python_first_truthy(cfg.call("claude_effort", DEFAULTS["claude_effort"]), "")),
+      dry_run: (args.dry_run ? true : _env_flag("DRY_RUN")),
+      verbose: (args.verbose ? true : _env_flag("VERBOSE")),
+      force: (args.force ? true : _env_flag("FORCE")),
+      list_only: (args.list_missing ? true : _env_flag("LIST_ONLY")),
+      parallel: parallel,
+      batch: python_first_truthy(args.batch, 0),
+      # These mirror bare `args.x or default` chains in the oracle (no str()
+      # wrapper), so values pass through uncoerced exactly as Python leaves them.
+      file: python_first_truthy(args.file, ""),
+      collection: python_first_truthy(args.collection, ""),
+      enhance: (args.enhance ? true : _env_flag("ENHANCE")),
+      enhance_prompt: python_first_truthy(args.enhance_prompt, ""),
+      enhance_model: python_first_truthy(args.enhance_model, ENV["ENHANCE_MODEL"], ENHANCE_DEFAULTS["model"]),
+      enhance_quality: python_first_truthy(args.enhance_quality, ENV["ENHANCE_QUALITY"], ENHANCE_DEFAULTS["quality"]),
+      enhance_fidelity: python_first_truthy(args.enhance_fidelity, ENV["ENHANCE_FIDELITY"], ENHANCE_DEFAULTS["fidelity"]),
+      enhance_format: python_first_truthy(args.enhance_format, ENV["ENHANCE_FORMAT"], ENHANCE_DEFAULTS["format"]),
+      rasterizer: pick.call(args.rasterizer, "IMAGE_RASTERIZER", "rasterizer"),
+      provider_explicit: !args.provider.nil? || python_bool(ENV["AI_PROVIDER"])
+    )
+  end
+
+  # Per-file settings copy with override blocks applied in order — later blocks
+  # win (pass collection styles first, author overrides on top). Returns the
+  # same object when nothing overrides, matching dataclasses.replace's identity
+  # short-circuit in the oracle.
+  def apply_preview_overrides(settings, *override_blocks)
+    merged = {}
+    override_blocks.each { |block| merged.update(block || {}) }
+    return settings if merged.empty?
+
+    changes = {}
+    OVERRIDE_KEYS.each do |key|
+      changes[key] = merged.key?(key) ? merged[key] : settings.public_send(key)
+    end
+    settings.dup_with(changes)
+  end
+
+  # The per-file settings: global → collection_styles[collection] → author
+  # preview: block (most specific wins). `cf` is any object exposing `path` and
+  # `author` (the ContentFile from the front-matter slice).
+  def file_preview_settings(settings, cf, authors)
+    coll_overrides = collection_preview_overrides(settings.collection_styles, collection_of(cf.path))
+    author_overrides = author_preview_overrides(authors, cf.author)
+    result = apply_preview_overrides(settings, coll_overrides, author_overrides)
+    info("  ↳ Collection '#{collection_of(cf.path)}' preview style applied") unless coll_overrides.empty?
+    unless author_overrides.empty?
+      info("  ↳ Author '#{cf.author}' preview overrides applied (#{settings.authors_file})")
+    end
+    result
+  end
+
+  # Model-name prefix → provider family, or nil. FIRST matching prefix wins, in
+  # MODEL_FAMILIES insertion order (see constants.rb).
+  def model_family(model)
+    m = (model || "").to_s.strip.downcase
+    MODEL_FAMILIES.each { |prefix, family| return family if m.start_with?(prefix) }
+    nil
+  end
+
+  # Configured model when it belongs to the provider's family, else the provider
+  # default (with a warning) — never emit a guaranteed-400 request. `provider`
+  # is any object exposing `name` and `default_model` (the Provider slice).
+  def effective_model(settings, provider)
+    model = (settings.model || "").to_s.strip
+    return provider.default_model if model.empty?
+
+    family = model_family(model)
+    if !family.nil? && family != provider.name
+      warn("Model '#{model}' belongs to the '#{family}' family; using " \
+           "#{provider.name} default '#{provider.default_model}' instead")
+      return provider.default_model
+    end
+    model
+  end
+end

data/lib/zer0_image_generator/stats.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Zer0ImageGenerator
+  # Per-run counters. Mirrors the Python @dataclass Stats: worker threads share
+  # one instance and call inc(name), so the mutation must be guarded (Python
+  # relied on its own threading.Lock here, not just the GIL — inc reads then
+  # writes, which is not atomic).
+  class Stats
+    ATTRS = %i[processed generated enhanced skipped errors].freeze
+
+    attr_accessor(*ATTRS)
+
+    def initialize(processed: 0, generated: 0, enhanced: 0, skipped: 0, errors: 0)
+      @processed = processed
+      @generated = generated
+      @enhanced = enhanced
+      @skipped = skipped
+      @errors = errors
+      @lock = Mutex.new
+    end
+
+    def inc(name)
+      key = name.to_sym
+      # Guard against a typo'd counter name silently doing nothing — the
+      # Python setattr would have raised too (AttributeError on a slotless
+      # write is not swallowed anywhere in the engine).
+      raise ArgumentError, "unknown stat: #{name}" unless ATTRS.include?(key)
+
+      @lock.synchronize { instance_variable_set("@#{key}", instance_variable_get("@#{key}") + 1) }
+      nil
+    end
+  end
+
+  # The engine's `_interrupted` global as an object, so the Runner can be
+  # handed a fresh one per run (a Rails worker cancels one job without
+  # poisoning the next). trip() is what _signal_handler does; tripped? is the
+  # `if _interrupted:` guard sprinkled through the run loop.
+  #
+  # NOT named `Interrupt`: that is a Ruby core class (the SIGINT exception), and
+  # this module is meant to be `include`d by a Rails host — the collision would
+  # shadow the core class for that host.
+  #
+  # Deliberately lock-free: trip() is called from a signal-trap context, where
+  # acquiring a Mutex raises ThreadError on modern Ruby. A single boolean
+  # write/read is safe under MRI's GVL, which is exactly what the Python global
+  # relied on too.
+  class InterruptFlag
+    def initialize
+      @flag = false
+    end
+
+    def trip
+      @flag = true
+      nil
+    end
+
+    def tripped?
+      @flag
+    end
+  end
+end

data/lib/zer0_image_generator/support/py_random.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Zer0ImageGenerator
+  module Support
+    # A bit-exact reimplementation of CPython's `random.Random`.
+    #
+    # Why this exists: the SVG generators ported from `tools/svg/` derive every
+    # coordinate from a seeded stream, and the sample artwork committed under
+    # `docs/samples/` was produced by CPython's Mersenne Twister. Ruby ships
+    # MT19937 too, but seeds it differently — `Random.new(7)` and
+    # `random.Random(7)` diverge on the first draw — so a port built on Ruby's
+    # own RNG would silently re-skin every existing piece.
+    #
+    # Reimplementing CPython's seeding (`init_by_array`) and its derived
+    # methods (`random`, `getrandbits`, `_randbelow`, `randrange`, `choice`,
+    # `uniform`) keeps the ported generators byte-identical to their Python
+    # originals, which `test/test_py_random.rb` and the golden-SVG tests pin.
+    #
+    # Only the surface the generators actually use is implemented; anything
+    # else would be untested weight.
+    class PyRandom
+      N = 624
+      M = 397
+      MATRIX_A = 0x9908b0df
+      UPPER_MASK = 0x80000000
+      LOWER_MASK = 0x7fffffff
+      MASK32 = 0xffffffff
+
+      # CPython divides `random()`'s 53 bits as 26 high + 27 low.
+      TWO_POW_26 = 67_108_864.0
+      TWO_POW_53 = 9_007_199_254_740_992.0
+
+      def initialize(seed = 0)
+        @mt = Array.new(N, 0)
+        @mti = N + 1
+        seed!(seed)
+      end
+
+      # CPython's random_seed(): integers are seeded by absolute value, split
+      # little-endian into 32-bit words, through init_by_array.
+      def seed!(seed)
+        n = seed.to_i.abs
+        key = []
+        if n.zero?
+          key << 0
+        else
+          while n.positive?
+            key << (n & MASK32)
+            n >>= 32
+          end
+        end
+        init_by_array(key)
+      end
+
+      def genrand_uint32
+        if @mti >= N
+          (0...(N - M)).each do |kk|
+            y = (@mt[kk] & UPPER_MASK) | (@mt[kk + 1] & LOWER_MASK)
+            @mt[kk] = @mt[kk + M] ^ (y >> 1) ^ (y.odd? ? MATRIX_A : 0)
+          end
+          ((N - M)...(N - 1)).each do |kk|
+            y = (@mt[kk] & UPPER_MASK) | (@mt[kk + 1] & LOWER_MASK)
+            @mt[kk] = @mt[kk + (M - N)] ^ (y >> 1) ^ (y.odd? ? MATRIX_A : 0)
+          end
+          y = (@mt[N - 1] & UPPER_MASK) | (@mt[0] & LOWER_MASK)
+          @mt[N - 1] = @mt[M - 1] ^ (y >> 1) ^ (y.odd? ? MATRIX_A : 0)
+          @mti = 0
+        end
+
+        y = @mt[@mti]
+        @mti += 1
+        y ^= (y >> 11)
+        y ^= (y << 7) & 0x9d2c5680
+        y ^= (y << 15) & 0xefc60000
+        y &= MASK32
+        y ^ (y >> 18)
+      end
+
+      # CPython: (a >> 5) * 2**26 + (b >> 6), scaled into [0, 1).
+      def random
+        a = genrand_uint32 >> 5
+        b = genrand_uint32 >> 6
+        ((a * TWO_POW_26) + b) / TWO_POW_53
+      end
+
+      def getrandbits(k)
+        raise ArgumentError, "number of bits must be non-negative" if k.negative?
+        return 0 if k.zero?
+        return genrand_uint32 >> (32 - k) if k <= 32
+
+        words = ((k - 1) / 32) + 1
+        result = 0
+        remaining = k
+        words.times do |i|
+          r = genrand_uint32
+          r >>= (32 - remaining) if remaining < 32
+          result |= r << (32 * i)
+          remaining -= 32
+        end
+        result
+      end
+
+      # CPython's _randbelow_with_getrandbits: rejection-sample bit_length bits.
+      def randbelow(n)
+        return 0 unless n.positive?
+
+        k = n.bit_length
+        r = getrandbits(k)
+        r = getrandbits(k) while r >= n
+        r
+      end
+
+      def randrange(start, stop = nil, step = 1)
+        if stop.nil?
+          raise ArgumentError, "empty range for randrange(#{start})" unless start.positive?
+
+          return randbelow(start)
+        end
+
+        width = stop - start
+        if step == 1
+          raise ArgumentError, "empty range for randrange(#{start}, #{stop})" unless width.positive?
+
+          return start + randbelow(width)
+        end
+
+        n = step.positive? ? ((width + step - 1) / step) : ((width + step + 1) / step)
+        raise ArgumentError, "empty range for randrange(#{start}, #{stop}, #{step})" unless n.positive?
+
+        start + (step * randbelow(n))
+      end
+
+      def randint(a, b)
+        randrange(a, b + 1)
+      end
+
+      def choice(seq)
+        raise ArgumentError, "cannot choose from an empty sequence" if seq.empty?
+
+        seq[randbelow(seq.length)]
+      end
+
+      def uniform(a, b)
+        a + ((b - a) * random)
+      end
+
+      private
+
+      def init_genrand(s)
+        @mt[0] = s & MASK32
+        (1...N).each do |i|
+          @mt[i] = (1_812_433_253 * (@mt[i - 1] ^ (@mt[i - 1] >> 30)) + i) & MASK32
+        end
+        @mti = N
+      end
+
+      def init_by_array(key)
+        init_genrand(19_650_218)
+        i = 1
+        j = 0
+        k = [N, key.length].max
+        while k.positive?
+          @mt[i] = ((@mt[i] ^ ((@mt[i - 1] ^ (@mt[i - 1] >> 30)) * 1_664_525)) + key[j] + j) & MASK32
+          i += 1
+          j += 1
+          if i >= N
+            @mt[0] = @mt[N - 1]
+            i = 1
+          end
+          j = 0 if j >= key.length
+          k -= 1
+        end
+
+        k = N - 1
+        while k.positive?
+          @mt[i] = ((@mt[i] ^ ((@mt[i - 1] ^ (@mt[i - 1] >> 30)) * 1_566_083_941)) - i) & MASK32
+          i += 1
+          if i >= N
+            @mt[0] = @mt[N - 1]
+            i = 1
+          end
+          k -= 1
+        end
+
+        @mt[0] = UPPER_MASK
+      end
+    end
+  end
+end