iriq 0.0.1 → 0.2.0

data/lib/iriq/corpus.rb

@@ -0,0 +1,322 @@
+require "json"
+
+module Iriq
+  # Streaming-friendly observer over a (potentially unbounded) corpus of IRIs.
+  # Maintains rolling aggregates and per-(host, prefix) frequency stats so
+  # that classification can improve as more data flows in.
+  #
+  # The deterministic, single-IRI API (Iriq.normalize/explain) is unchanged —
+  # Corpus#normalize and Corpus#explain are the corpus-informed variants.
+  #
+  # State lives in a Storage backend (Memory by default; Json or Sqlite when
+  # opened against a file). The classification logic on top is identical
+  # regardless of where the counters live.
+  class Corpus
+    # Type-based: position is "mostly variable" (UUIDs/integers/etc.).
+    VARIABLE_DOMINANCE_THRESHOLD = 0.8
+
+    # Cardinality-based: position has mostly distinct literal values, so the
+    # literal "type" is misleading — it's really a variable slot. We trigger
+    # on either:
+    #   - very high cardinality fraction (most observations are singletons), OR
+    #   - moderate cardinality fraction AND high absolute distinct count
+    # The second branch catches realistic streams where popular outliers
+    # bring the frac down but the long tail is clearly variable.
+    LITERAL_UNIQUENESS_THRESHOLD          = 0.8
+    LITERAL_UNIQUENESS_MODERATE_THRESHOLD = 0.5
+    MIN_CARDINALITY_FOR_INFERENCE         = 20
+
+    # Don't apply corpus heuristics until we have at least this many
+    # observations at a position — too easy to be wrong with tiny samples.
+    MIN_OBSERVATIONS_FOR_INFERENCE = 5
+
+    # Value-fraction at or above which a literal is considered the stable
+    # occupant of its position.
+    STABLE_LITERAL_THRESHOLD = 0.5
+
+    # Within a high-cardinality literal position (mostly singletons), a
+    # specific value qualifies as a "popular outlier" — and gets preserved
+    # as :stable_literal instead of being lumped into :corpus_inferred_variable
+    # — when its count is at least POPULAR_MIN_COUNT and its frequency is at
+    # least POPULAR_BASELINE_MULTIPLE × the uniform baseline (1/cardinality).
+    POPULAR_MIN_COUNT         = 5
+    POPULAR_BASELINE_MULTIPLE = 3
+
+    attr_reader :storage
+
+    def initialize(classifier: SegmentClassifier::DEFAULT,
+                   max_values_per_position: PositionStats::DEFAULT_MAX_VALUES,
+                   storage: nil)
+      @classifier = classifier
+      @storage    = storage || Storage::Memory.new(
+        classifier: classifier,
+        max_values_per_position: max_values_per_position,
+      )
+    end
+
+    # Open a corpus against `path`. File extension picks the backend:
+    # `.db`/`.sqlite`/`.sqlite3` use SQLite (incremental writes); anything
+    # else uses JSON.
+    def self.open(path, classifier: SegmentClassifier::DEFAULT,
+                        max_values_per_position: PositionStats::DEFAULT_MAX_VALUES)
+      storage = Storage.open(path,
+                             classifier: classifier,
+                             max_values_per_position: max_values_per_position)
+      new(classifier: classifier, storage: storage)
+    end
+
+    # Observe a single IRI. Returns an Observation.
+    def observe(input)
+      iri = coerce(input)
+      hinted_entries = SegmentHints.derive(iri.path_segments, @classifier)
+      raw_shape    = PathShape.new(classifier: @classifier, hints: false).from_entries(hinted_entries)
+      hinted_shape = PathShape.new(classifier: @classifier, hints: true).from_entries(hinted_entries)
+
+      cluster = nil
+      @storage.transaction do |s|
+        s.increment_host(iri.host)
+        s.increment_path_length(iri.path_segments.size)
+        s.increment_raw_shape(raw_shape)
+        s.increment_fingerprint(hinted_shape)
+
+        prefix = ""
+        hinted_entries.each do |entry|
+          s.observe_position(iri.host, prefix, entry[:value], entry[:type])
+          prefix = "#{prefix}/#{placeholder(entry)}"
+        end
+
+        key, host, scheme, shape = Cluster.key_for(iri, classifier: @classifier, shape: hinted_shape)
+        cluster = s.add_to_cluster(key, host, scheme, shape, iri)
+      end
+
+      Observation.new(corpus: self, identifier: iri, cluster: cluster)
+    end
+
+    # Corpus-informed normalization. Falls back to mechanical normalization
+    # when the corpus has no signal for a position.
+    def normalize(input)
+      iri = coerce(input)
+      return Normalizer.normalize_identifier(iri) if iri.urn? || iri.path_segments.empty?
+
+      tokens = annotate_segments(iri).map { |entry| corpus_token(entry) }
+      out = +""
+      out << "#{iri.scheme}://" if iri.scheme
+      out << iri.host if iri.host
+      out << ":#{iri.port}" if iri.port
+      out << "/" << tokens.join("/")
+      out
+    end
+
+    # Per-segment explanation with corpus-informed `classification`.
+    # Returns an array of entries shaped like the Explanation rows plus
+    # `classification:` ∈ :stable_literal, :variable_identifier,
+    # :rare_literal, :ambiguous, :corpus_inferred_variable.
+    def explain(input)
+      iri = coerce(input)
+      annotate_segments(iri).map do |entry|
+        entry.reject { |k, _| k == :prefix }
+      end
+    end
+
+    def host_counts;        @storage.host_counts;        end
+    def path_length_counts; @storage.path_length_counts; end
+    def raw_shape_counts;   @storage.raw_shape_counts;   end
+    def fingerprint_counts; @storage.fingerprint_counts; end
+
+    # Iterates (host, prefix) → PositionStats over all observed positions.
+    # Used by inspection tooling; not part of the hot path.
+    def each_position_stats(&block)
+      @storage.each_position_stats(&block)
+    end
+
+    def clusters
+      @storage.clusters
+    end
+
+    def size
+      @storage.cluster_size
+    end
+
+    # Stats for a given (host, prefix_shape) — useful for tests and
+    # debugging. Returns nil if nothing has been observed there.
+    def stats_for(host, prefix)
+      @storage.position_stats(host, prefix)
+    end
+
+    # Persist the corpus.
+    #
+    #   save()           → flush the backend in place (JSON writes its file,
+    #                      SQLite is already on disk).
+    #   save(same_path)  → same as save() — idempotent for the backend's path.
+    #   save(other_path) → export to other_path as JSON, regardless of the
+    #                      live backend.
+    def save(path = nil)
+      backend_path = @storage.respond_to?(:path) ? @storage.path : nil
+      if path.nil? || path == backend_path
+        @storage.save
+      else
+        write_json_dump(path)
+      end
+    end
+
+    def close
+      @storage.close
+    end
+
+    # Wrap many observations in a single backend transaction. For SQLite this
+    # turns thousands of fsyncs into one; for in-memory backends it's a
+    # no-op. Use when ingesting a batch.
+    def batch(&block)
+      @storage.batch(&block)
+    end
+
+    private
+
+    def coerce(input)
+      input.is_a?(Identifier) ? input : Parser.parse(input)
+    end
+
+    def annotate_segments(iri)
+      hinted = SegmentHints.derive(iri.path_segments, @classifier)
+      prefix = ""
+      hinted.map do |entry|
+        stats = @storage.position_stats(iri.host, prefix)
+        out = entry.merge(
+          prefix:         prefix,
+          classification: classify(entry, stats),
+        )
+        prefix = "#{prefix}/#{placeholder(entry)}"
+        out
+      end
+    end
+
+    def placeholder(entry)
+      return entry[:value] unless entry[:variable]
+
+      "{#{entry[:hint] || entry[:type]}}"
+    end
+
+    def classify(entry, stats)
+      variable = entry[:variable]
+
+      return variable ? :variable_identifier : :ambiguous if stats.nil? || stats.total.zero?
+      return :variable_identifier if variable
+
+      value            = entry[:value]
+      total            = stats.total
+      variable_frac    = stats.variable_fraction(@classifier)
+      cardinality_frac = stats.cardinality.to_f / total
+      enough_data      = total >= MIN_OBSERVATIONS_FOR_INFERENCE
+      value_frac       = stats.value_fraction(value)
+
+      if enough_data && variable_frac >= VARIABLE_DOMINANCE_THRESHOLD
+        # Position is dominated by variable types (UUIDs, integers, etc.).
+        # A literal here is a special-case outlier (e.g. /users/me).
+        stats.value_counts.key?(value) ? :rare_literal : :ambiguous
+      elsif value_frac >= STABLE_LITERAL_THRESHOLD
+        # This specific value dominates — preserve it regardless of how
+        # diverse the rest of the position is.
+        :stable_literal
+      elsif enough_data && high_cardinality_literal_position?(stats, cardinality_frac)
+        # High-cardinality literal position — usually a variable slot, but
+        # recognize values that dramatically exceed the uniform baseline as
+        # "popular outliers" (e.g. /workspaces/mainspace surviving in a slot
+        # full of one-shot user-created workspace names).
+        popular_outlier?(stats, value) ? :stable_literal : :corpus_inferred_variable
+      elsif stats.cardinality == 1
+        :stable_literal
+      elsif stats.value_counts.key?(value)
+        :rare_literal
+      else
+        :ambiguous
+      end
+    end
+
+    def high_cardinality_literal_position?(stats, cardinality_frac)
+      return true if cardinality_frac >= LITERAL_UNIQUENESS_THRESHOLD
+
+      cardinality_frac >= LITERAL_UNIQUENESS_MODERATE_THRESHOLD &&
+        stats.cardinality >= MIN_CARDINALITY_FOR_INFERENCE
+    end
+
+    def popular_outlier?(stats, value)
+      count = stats.value_counts[value] || 0
+      return false if count < POPULAR_MIN_COUNT
+
+      baseline = 1.0 / stats.cardinality
+      stats.value_fraction(value) >= POPULAR_BASELINE_MULTIPLE * baseline
+    end
+
+    def corpus_token(entry)
+      case entry[:classification]
+      when :variable_identifier, :corpus_inferred_variable
+        placeholder_for_variable(entry)
+      else
+        entry[:value]
+      end
+    end
+
+    def placeholder_for_variable(entry)
+      return "{#{entry[:hint] || entry[:type]}}" if entry[:variable]
+
+      # corpus-inferred variable: classifier said literal, corpus says
+      # otherwise. Derive a hint from the prefix's last literal segment if
+      # we can.
+      last_literal = entry[:prefix].split("/").reject(&:empty?).reject { |s| s.start_with?("{") }.last
+      base = last_literal ? Inflector.singularize(last_literal) : nil
+      base ? "{#{base}}" : "{value}"
+    end
+
+    public
+
+    # --- Legacy dump/load (JSON shape) ------------------------------------
+    #
+    # The pre-Storage release exposed `Corpus#dump`, `Corpus#save(path)`, and
+    # `Corpus.load(path)` for JSON-backed persistence. Those names still work
+    # but are now thin wrappers around the appropriate Storage backend.
+
+    def dump
+      memory_view.to_dump
+    end
+
+    def self.from_dump(h, classifier: SegmentClassifier::DEFAULT)
+      max_values = h.fetch("max_values_per_position", PositionStats::DEFAULT_MAX_VALUES)
+      storage = Storage::Memory.new(classifier: classifier, max_values_per_position: max_values)
+      storage.load_dump!(h)
+      new(classifier: classifier, storage: storage)
+    end
+
+    def self.load(path, classifier: SegmentClassifier::DEFAULT)
+      open(path, classifier: classifier)
+    end
+
+    private
+
+    def write_json_dump(path)
+      tmp = "#{path}.tmp"
+      File.write(tmp, JSON.generate(memory_view.to_dump))
+      File.rename(tmp, path)
+    end
+
+    # Materialize a Memory snapshot of the current state — used by dump for
+    # backends that don't natively know how to emit the JSON shape.
+    def memory_view
+      return @storage if @storage.respond_to?(:to_dump)
+
+      mem = Storage::Memory.new(
+        classifier: @classifier,
+        max_values_per_position: @storage.max_values_per_position,
+      )
+      mem.instance_variable_set(:@host_counts,        Hash.new(0).merge(@storage.host_counts))
+      mem.instance_variable_set(:@path_length_counts, Hash.new(0).merge(@storage.path_length_counts))
+      mem.instance_variable_set(:@raw_shape_counts,   Hash.new(0).merge(@storage.raw_shape_counts))
+      mem.instance_variable_set(:@fingerprint_counts, Hash.new(0).merge(@storage.fingerprint_counts))
+      ps = {}
+      @storage.each_position_stats { |key, stats| ps[key] = stats }
+      mem.instance_variable_set(:@position_stats, ps)
+      clusters_h = @storage.clusters.each_with_object({}) { |c, h| h[c.key] = c }
+      mem.instance_variable_set(:@clusters, clusters_h)
+      mem
+    end
+  end
+end

data/lib/iriq/explanation.rb

@@ -3,43 +3,27 @@ module Iriq
   #
   #   Explanation.explain("https://foo.com/users/123")
   #   # => [
-  #   #      { value: "users", type: :literal,    variable: false },
-  #   #      { value: "123",   type: :integer_id, variable: true },
+  #   #      { value: "users", type: :literal,    variable: false, hint: nil       },
+  #   #      { value: "123",   type: :integer_id, variable: true,  hint: "user_id" },
   #   #    ]
   module Explanation
     module_function
 
-    def explain(input, classifier: SegmentClassifier.new)
+    def explain(input, classifier: SegmentClassifier::DEFAULT)
       iri = input.is_a?(Identifier) ? input : Parser.parse(input)
 
       if iri.urn?
         explain_urn(iri, classifier)
       else
-        iri.path_segments.map { |s| segment_entry(s, classifier) }
+        SegmentHints.derive(iri.path_segments, classifier)
       end
     end
 
-    def segment_entry(segment, classifier)
-      type = classifier.classify(segment)
-      {
-        value:    segment,
-        type:     type,
-        variable: classifier.variable?(type),
-      }
-    end
-
     def explain_urn(iri, classifier)
       return [] unless iri.nss
 
-      if iri.nss.include?(":")
-        ns, value = iri.nss.split(":", 2)
-        [
-          { value: ns, type: :literal, variable: false },
-          segment_entry(value, classifier),
-        ]
-      else
-        [segment_entry(iri.nss, classifier)]
-      end
+      parts = iri.nss.include?(":") ? iri.nss.split(":", 2) : [iri.nss]
+      SegmentHints.derive(parts, classifier)
     end
   end
 end

data/lib/iriq/extractor.rb

@@ -0,0 +1,125 @@
+module Iriq
+  # Pulls IRIs out of free text. Scheme-anchored — only URLs whose scheme
+  # appears explicitly are extracted (scheme-less hosts like "foo.com/x" are
+  # too noisy to disambiguate from prose).
+  #
+  #   Iriq::Extractor.new.extract("Visit https://foo.com today.")
+  #   # => [#<Iriq::Identifier https://foo.com>]
+  #
+  # Design draws on twitter-text and GFM autolink rules: scheme anchoring,
+  # iterative trailing-punct trim, balanced-paren preservation.
+  class Extractor
+    SCHEMES = %w[https http ftp wss ws].freeze
+
+    # Conservative TLD allow-list for scheme-less extraction. Limited to a
+    # small set of very common TLDs to keep false-positive rate low. A
+    # scheme-less candidate ALSO requires a `/path` to count, so plain
+    # `foo.com` in prose still won't match — only `foo.com/something`.
+    SCHEMELESS_TLDS = %w[com org net io ai dev co app gov edu].freeze
+
+    # Boundary chars — a URL ends at any of these (whitespace, angle
+    # brackets, quotes, backtick).
+    BOUNDARY = %r{[\s<>"'`]}.freeze
+
+    # Non-ASCII Unicode brackets and quotation marks that almost always
+    # terminate a URL in source text (e.g. `「URL」`). ASCII brackets are NOT
+    # listed here — those stay inside the URL match so the balanced-paren
+    # trim step can handle them (Wikipedia URLs like /Foo_(bar) survive).
+    NON_ASCII_BOUNDARY = (
+      "」』）】〉》〕〗〙〛｠｝］＞" +  # CJK closing brackets
+      "「『（【〈《〔〖〘〚｟｛［＜" +  # CJK opening brackets
+      "“”‘’„‟‚«»‹›"                 # Unicode quotation marks
+    ).chars.uniq.join.freeze
+
+    URL_CHAR_CLASS = %{[^\\s<>"'`,#{NON_ASCII_BOUNDARY}]+}.freeze
+
+    CANDIDATE_RE = %r{
+      (?<![\w/])                                                    # not mid-word, not mid-path
+      (?:
+        (?i:#{SCHEMES.join("|")})://#{URL_CHAR_CLASS}               # absolute URL
+        |
+        urn:[a-zA-Z0-9][a-zA-Z0-9\-]{0,30}:#{URL_CHAR_CLASS}        # urn:NID:NSS
+      )
+    }xu.freeze
+
+    # Scheme-less alternative — same chars allowed as the absolute URL but
+    # requires a host with an allow-listed TLD AND a `/path` to keep prose
+    # noise low. The host part allows ASCII labels separated by dots; no
+    # Unicode hosts (those are too easily confused with prose).
+    SCHEMELESS_ALT = %{(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+(?i:#{SCHEMELESS_TLDS.join("|")})/#{URL_CHAR_CLASS}}.freeze
+
+    # Single-scan combined pattern used when scheme_less is on. One regex
+    # over the text is meaningfully cheaper than two.
+    COMBINED_RE = %r{
+      (?<![\w/.@])
+      (?:
+        (?i:#{SCHEMES.join("|")})://#{URL_CHAR_CLASS}
+        |
+        urn:[a-zA-Z0-9][a-zA-Z0-9\-]{0,30}:#{URL_CHAR_CLASS}
+        |
+        #{SCHEMELESS_ALT}
+      )
+    }xu.freeze
+
+    # Punctuation that's almost always sentence punctuation rather than part
+    # of a URL when it appears at the trailing edge.
+    TRAILING_PUNCT_RE = /[.,;:!?'"‘’“”]+\z/u.freeze
+
+    # Unmatched closing brackets that should be trimmed.
+    BRACKET_PAIRS = { ")" => "(", "]" => "[", "}" => "{" }.freeze
+
+    def initialize(scheme_less: true)
+      @scheme_less = scheme_less
+    end
+
+    def extract(text)
+      return [] if text.nil? || text.empty?
+
+      candidates = scan_candidates(text)
+      candidates.filter_map do |candidate|
+        trimmed = trim(candidate)
+        next nil if trimmed.empty?
+
+        begin
+          Parser.parse(trimmed)
+        rescue ParseError
+          nil
+        end
+      end
+    end
+
+    # Same as extract but returns only canonical strings, deduplicated,
+    # preserving first-seen order.
+    def extract_strings(text)
+      seen = {}
+      extract(text).each { |iri| seen[iri.canonical] ||= true }
+      seen.keys
+    end
+
+    private
+
+    # One regex scan over the text — combined pattern when scheme-less is
+    # on, scheme-anchored only otherwise.
+    def scan_candidates(text)
+      pattern = @scheme_less ? COMBINED_RE : CANDIDATE_RE
+      text.scan(pattern)
+    end
+
+    # Iteratively strip sentence punctuation and unmatched closing brackets
+    # until the candidate stabilizes.
+    def trim(candidate)
+      s = candidate.dup
+      loop do
+        before = s
+        s = s.sub(TRAILING_PUNCT_RE, "")
+        BRACKET_PAIRS.each do |close, open|
+          while s.end_with?(close) && s.count(close) > s.count(open)
+            s = s[0...-1]
+          end
+        end
+        break if s == before
+      end
+      s
+    end
+  end
+end

data/lib/iriq/identifier.rb

@@ -43,9 +43,17 @@ module Iriq
         out << "#{scheme}://" if scheme
         out << host if host
         out << ":#{port}" if port
-        out << "/" + path_segments.join("/") if path_segments.any?
-        out << "?#{query}" if query && !query.empty?
-        out << "##{fragment}" if fragment && !fragment.empty?
+        has_query    = query && !query.empty?
+        has_fragment = fragment && !fragment.empty?
+        if path_segments.any?
+          out << "/" + path_segments.join("/")
+        elsif has_query || has_fragment
+          # RFC 3986: an authority with query/fragment but no path needs the
+          # implied "/" to be a valid URI.
+          out << "/"
+        end
+        out << "?#{query}"    if has_query
+        out << "##{fragment}" if has_fragment
         out
       end
     end

data/lib/iriq/inflector.rb

@@ -0,0 +1,145 @@
+require "set"
+
+module Iriq
+  # Singularization with a swappable adapter.
+  #
+  # By default uses ActiveSupport's inflector if it can be required, otherwise
+  # falls back to BuiltinAdapter. Override globally:
+  #
+  #   Iriq::Inflector.adapter = MyAdapter   # must respond to .singularize(String)
+  #
+  # And reset to default with `Iriq::Inflector.reset_adapter!`.
+  module Inflector
+    # Vocabulary is bounded in practice; cache + cap matches the
+    # SegmentClassifier strategy.
+    CACHE_MAX = 10_000
+
+    class << self
+      def singularize(word)
+        cache = (@cache ||= {})
+        cached = cache[word]
+        return cached if cached
+
+        cache.clear if cache.size >= CACHE_MAX
+        cache[word] = adapter.singularize(word)
+      end
+
+      def adapter
+        @adapter ||= default_adapter
+      end
+
+      def adapter=(value)
+        @adapter = value
+        @cache = {} # different adapter could singularize differently
+      end
+
+      def reset_adapter!
+        @adapter = nil
+        @cache = {}
+      end
+
+      def default_adapter
+        require "active_support/inflector"
+        ActiveSupportAdapter
+      rescue LoadError
+        BuiltinAdapter
+      end
+    end
+
+    module ActiveSupportAdapter
+      def self.singularize(word)
+        ::ActiveSupport::Inflector.singularize(word.to_s)
+      end
+    end
+
+    # Rule-based English singularizer. Rules are ordered most-specific-first
+    # and adapted from ActiveSupport's default inflections.
+    module BuiltinAdapter
+      IRREGULARS = {
+        "people"   => "person",
+        "children" => "child",
+        "men"      => "man",
+        "women"    => "woman",
+        "mice"     => "mouse",
+        "geese"    => "goose",
+        "oxen"     => "ox",
+        "feet"     => "foot",
+        "teeth"    => "tooth",
+        "lives"    => "life",
+        "wives"    => "wife",
+        "moves"    => "move",
+        "zombies"  => "zombie",
+        # latin/greek plurals that don't fit a clean suffix rule
+        "indices"  => "index",
+        "vertices" => "vertex",
+        # -f/-fe words where the stem doesn't end in l/r/i
+        "leaves"   => "leaf",
+        "calves"   => "calf",
+        "halves"   => "half",
+        "loaves"   => "loaf",
+        "hooves"   => "hoof",
+      }.freeze
+
+      UNCOUNTABLE = Set.new(%w[
+        news fish sheep deer series species equipment information
+        money rice jeans police data media
+      ]).freeze
+
+      # [pattern, replacement] — first match wins.
+      RULES = [
+        [/(quiz)zes$/i,                       '\1'],
+        [/(matri|appendi)ces$/i,              '\1x'],
+        [/(ox)en$/i,                          '\1'],
+        [/(alias|status)(es)?$/i,             '\1'],
+        [/(octop|vir)(us|i)$/i,               '\1us'],
+        [/(cris|ax|test)es$/i,                '\1is'],
+        [/(shoe)s$/i,                         '\1'],
+        [/(bus)(es)?$/i,                      '\1'],
+        [/([ml])ice$/i,                       '\1ouse'],
+        [/(x|ch|ss|sh)es$/i,                  '\1'],
+        [/(m)ovies$/i,                        '\1ovie'],
+        [/(s)eries$/i,                        '\1eries'],
+        [/([^aeiouy]|qu)ies$/i,               '\1y'],
+        [/([lr])ves$/i,                       '\1f'],
+        [/(tive)s$/i,                         '\1'],
+        [/(hive)s$/i,                         '\1'],
+        [/([^f])ves$/i,                       '\1fe'],
+        [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1sis'],
+        [/([ti])a$/i,                         '\1um'],
+        [/(n)ews$/i,                          '\1ews'],
+        [/(o)es$/i,                           '\1'],
+        [/(ss)$/i,                            '\1'],
+        [/s$/i,                               ''],
+      ].freeze
+
+      def self.singularize(word)
+        return word if word.nil? || word.empty?
+
+        lower = word.downcase
+        return word if UNCOUNTABLE.include?(lower)
+
+        if (irr = IRREGULARS[lower])
+          return preserve_case(word, irr)
+        end
+
+        RULES.each do |pattern, replacement|
+          if word.match?(pattern)
+            return word.sub(pattern, replacement)
+          end
+        end
+
+        word
+      end
+
+      def self.preserve_case(original, lowered)
+        if original == original.upcase
+          lowered.upcase
+        elsif original[0] == original[0].upcase
+          lowered.sub(/\A./, &:upcase)
+        else
+          lowered
+        end
+      end
+    end
+  end
+end