iriq 0.2.0 → 0.33.0

data/lib/iriq/synthesized_recognizer.rb

@@ -0,0 +1,56 @@
+module Iriq
+  # Recognizer built dynamically from a learned-prefix pattern.
+  #
+  # Used by Corpus#activate_proposal to promote a RecognizerProposal
+  # into a live Recognizer that the classifier ensemble consults. Same
+  # shape as the built-in Recognizers — uuid, date, integer — but the
+  # pattern + type are supplied at construction instead of compiled-in.
+  #
+  #   r = SynthesizedRecognizer.new(prefix: "ghp_", type: :ghp)
+  #   r.try("ghp_abcdef123")  # → {type: :ghp, confidence: 1.0, specificity: 1.0}
+  #
+  # Pattern: `<prefix><[A-Za-z0-9]+>` — anchored, alphanumeric suffix
+  # only. Matches the same shape PrefixUnderscoreId proposes from, so
+  # round-trip (propose → activate → reinfer) reclassifies the same
+  # values the proposal was derived from.
+  #
+  # Specificity defaults to SEMANTIC. A learned prefix is very specific
+  # by construction (a distinctive literal prefix that recurred enough
+  # to clear the proposal noise floor) — calling it as confident as a
+  # built-in UUID is reasonable.
+  class SynthesizedRecognizer < Recognizer
+    attr_reader :prefix, :type, :specificity
+
+    def self.from_proposal(proposal)
+      new(prefix: proposal.prefix, type: proposal.suggested_type)
+    end
+
+    def initialize(prefix:, type:, specificity: Specificity::SEMANTIC)
+      raise ArgumentError, "prefix must be a non-empty string" if prefix.nil? || prefix.empty?
+      raise ArgumentError, "type must be a symbol" unless type.is_a?(Symbol)
+
+      @prefix      = prefix
+      @type        = type
+      @specificity = specificity
+      @pattern     = /\A#{Regexp.escape(prefix)}[A-Za-z0-9]+\z/.freeze
+    end
+
+    def try(segment)
+      return nil unless segment.start_with?(@prefix) && @pattern.match?(segment)
+
+      { type: @type, confidence: 1.0, specificity: @specificity }
+    end
+
+    def to_dump
+      { "prefix" => @prefix, "type" => @type.to_s, "specificity" => @specificity }
+    end
+
+    def self.from_dump(h)
+      new(
+        prefix:      h["prefix"],
+        type:        h["type"].to_sym,
+        specificity: h.fetch("specificity", Specificity::SEMANTIC),
+      )
+    end
+  end
+end

data/lib/iriq/trace.rb

@@ -0,0 +1,294 @@
+module Iriq
+  # Produces an annotated trace explaining how an identifier got
+  # normalized — segment by segment, with notes for each non-obvious
+  # transformation (currency upcase, IP umbrella, hint suppression,
+  # canonical date, param-name lift, etc.).
+  #
+  #   Trace.for("https://shop.com/pricing/usd?currency=eur")
+  #   # => {
+  #   #      input: "...",
+  #   #      normalized: "https://shop.com/pricing/USD?currency=EUR",
+  #   #      scheme: "https", host: "shop.com",
+  #   #      path:  [...per-segment rows...],
+  #   #      query: [...per-param rows...],
+  #   #    }
+  #
+  # Each row is `{ value, type, output, notes }` for path entries and
+  # `{ name, value, type, output, notes }` for query entries. The string
+  # notes are rendered from structured Iriq::Evidence::Record values;
+  # callers that want the structured form can use Trace.evidence_for.
+  module Trace
+    module_function
+
+    HINT_NOTE_TEMPLATE = "semantic type — surfaced as {%s}, not {%s}".freeze
+
+    # Render-ready Trace output. The public format consumers depend on.
+    def for(input, classifier: SegmentClassifier::DEFAULT, hints: true)
+      iri = coerce(input)
+      normalized = Normalizer.normalize_identifier(iri, classifier: classifier, hints: hints)
+
+      out = {
+        input:      iri.canonical,
+        normalized: normalized,
+        scheme:     iri.scheme,
+        host:       iri.host,
+      }
+      out[:port] = iri.port if iri.port
+
+      if iri.urn?
+        out[:path] = urn_rows(iri, classifier, hints)
+      else
+        out[:path]  = path_rows(iri.path_segments, classifier, hints)
+        if iri.query_params && !iri.query_params.empty?
+          out[:query] = query_rows(iri.query_params, classifier)
+        end
+      end
+
+      out
+    end
+
+    # Structured Evidence list for `input`. Each segment + query param
+    # contributes one classification Evidence plus zero or more
+    # transformation Evidence records (canonical date, IP umbrella
+    # collapse, param-name hint, hint suppression).
+    #
+    # Position + Cluster Evidence are not emitted here — they belong to
+    # corpus-informed trace (Corpus#trace), which a follow-up step lands.
+    def evidence_for(input, classifier: SegmentClassifier::DEFAULT, hints: true)
+      iri      = coerce(input)
+      records  = []
+      segments = iri.urn? ? urn_parts(iri) : (iri.path_segments || [])
+      entries  = SegmentHints.derive(segments, classifier)
+
+      entries.each_with_index do |entry, i|
+        records.concat(segment_evidence(entry, segments, i, classifier, hints))
+      end
+
+      if !iri.urn? && iri.query_params && !iri.query_params.empty?
+        iri.query_params.keys.sort.each do |k|
+          records.concat(query_param_evidence(k, iri.query_params[k].to_s, classifier))
+        end
+      end
+
+      records
+    end
+
+    # ── Evidence builders ────────────────────────────────────────────────
+
+    def segment_evidence(entry, segments, idx, classifier, hints)
+      records = []
+
+      records << Evidence.segment(
+        index: idx, value: entry[:value],
+        source:  :recognizer,
+        payload: { type: entry[:type], variable: entry[:variable], hint: entry[:hint] },
+      )
+
+      if entry[:variable]
+        if entry[:type] == :date && (canon = SegmentClassifier.canonical_date(entry[:value]))
+          if canon != entry[:value]
+            records << Evidence.segment(
+              index: idx, value: entry[:value],
+              source:  :policy,
+              payload: { rule: :canonical_date, before: entry[:value], after: canon },
+              notes:   ["canonical date (#{entry[:value]} → #{canon})"],
+            )
+          end
+        elsif entry[:type] == :currency && (canon = SegmentClassifier.canonical_currency(entry[:value]))
+          if canon != entry[:value]
+            records << Evidence.segment(
+              index: idx, value: entry[:value],
+              source:  :policy,
+              payload: { rule: :canonical_currency, before: entry[:value], after: canon },
+              notes:   ["currency upcase (#{entry[:value]} → #{canon})"],
+            )
+          end
+        else
+          extra = placeholder_decoration_evidence(entry, segments, idx, classifier, hints)
+          records.concat(extra)
+        end
+      end
+
+      records
+    end
+
+    def placeholder_decoration_evidence(entry, segments, idx, classifier, hints)
+      out  = []
+      type = entry[:type]
+
+      if type == :ipv4 || type == :ipv6
+        out << Evidence.segment(
+          index: idx, value: entry[:value],
+          source:  :policy,
+          payload: { rule: :ip_umbrella_collapse, from: type, to: :ip },
+          notes:   ["ip umbrella collapse (#{type} → ip)"],
+        )
+      end
+
+      if hints && entry[:hint].nil? && !SegmentHints::HINT_ELIGIBLE_TYPES.include?(type)
+        if (would_be = would_be_hint(segments, idx, type, classifier))
+          display = SegmentClassifier.display_type(type)
+          out << Evidence.segment(
+            index: idx, value: entry[:value],
+            source:  :neighbor,
+            payload: { rule: :hint_suppression, surfaced: display, would_be: would_be, semantic_type: type },
+            notes:   [format(HINT_NOTE_TEMPLATE, display, would_be)],
+          )
+        end
+      end
+
+      out
+    end
+
+    def query_param_evidence(name, value, classifier)
+      records   = []
+      base_type = classifier.classify(value)
+      effective = base_type
+
+      if (hint = SegmentClassifier.param_name_hint(name, base_type))
+        effective = hint
+        records << Evidence.segment(
+          index: name, value: value,
+          source:  :neighbor,
+          payload: { rule: :param_name_hint, name: name, before: base_type, after: hint },
+          notes:   ["param-name hint (`#{name}=`) lifted #{base_type} → #{hint}"],
+        )
+      end
+
+      records << Evidence.segment(
+        index: name, value: value,
+        source:  :recognizer,
+        payload: { type: effective, variable: SegmentClassifier::DEFAULT.variable?(effective) },
+      )
+
+      if effective == :date && (canon = SegmentClassifier.canonical_date(value))
+        if canon != value
+          records << Evidence.segment(
+            index: name, value: value,
+            source:  :policy,
+            payload: { rule: :canonical_date, before: value, after: canon },
+            notes:   ["canonical date (#{value} → #{canon})"],
+          )
+        end
+      elsif effective == :currency && (canon = SegmentClassifier.canonical_currency(value))
+        if canon != value
+          records << Evidence.segment(
+            index: name, value: value,
+            source:  :policy,
+            payload: { rule: :canonical_currency, before: value, after: canon },
+            notes:   ["currency upcase (#{value} → #{canon})"],
+          )
+        end
+      elsif effective == :ipv4 || effective == :ipv6
+        records << Evidence.segment(
+          index: name, value: value,
+          source:  :policy,
+          payload: { rule: :ip_umbrella_collapse, from: effective, to: :ip },
+          notes:   ["ip umbrella collapse (#{effective} → ip)"],
+        )
+      end
+
+      records
+    end
+
+    # ── View rendering (Evidence → Trace.for hash) ───────────────────────
+
+    def path_rows(segments, classifier, hints)
+      return [] if segments.nil? || segments.empty?
+
+      entries = SegmentHints.derive(segments, classifier)
+      entries.each_with_index.map do |entry, i|
+        ev = segment_evidence(entry, segments, i, classifier, hints)
+        render_segment_row(entry, ev, hints)
+      end
+    end
+
+    def urn_rows(iri, classifier, hints)
+      parts = urn_parts(iri)
+      return [] if parts.empty?
+
+      entries = SegmentHints.derive(parts, classifier)
+      entries.each_with_index.map do |entry, i|
+        ev = segment_evidence(entry, parts, i, classifier, hints)
+        render_segment_row(entry, ev, hints)
+      end
+    end
+
+    def query_rows(params, classifier)
+      params.keys.sort.map do |k|
+        v  = params[k].to_s
+        ev = query_param_evidence(k, v, classifier)
+        render_query_row(k, v, ev)
+      end
+    end
+
+    def render_segment_row(entry, evidence, hints)
+      notes = collect_notes(evidence)
+      value = entry[:value]
+      type  = entry[:type]
+
+      return { value: value, type: type, output: value, notes: notes } unless entry[:variable]
+
+      canon_policy = find_payload(evidence, :canonical_date) || find_payload(evidence, :canonical_currency)
+      if canon_policy
+        return { value: value, type: type, output: canon_policy[:after], notes: notes }
+      end
+
+      placeholder = hints && entry[:hint] ? entry[:hint].to_s : SegmentClassifier.display_type(type).to_s
+      { value: value, type: type, output: "{#{placeholder}}", notes: notes }
+    end
+
+    def render_query_row(name, value, evidence)
+      notes        = collect_notes(evidence)
+      cls          = find_evidence(evidence, source: :recognizer)
+      effective    = cls ? cls.payload[:type] : SegmentClassifier::DEFAULT.classify(value)
+      canon_policy = find_payload(evidence, :canonical_date) || find_payload(evidence, :canonical_currency)
+
+      output =
+        if canon_policy
+          canon_policy[:after]
+        elsif SegmentClassifier::DEFAULT.variable?(effective)
+          "{#{SegmentClassifier.display_type(effective)}}"
+        else
+          value
+        end
+
+      { name: name, value: value, type: effective, output: output, notes: notes }
+    end
+
+    # ── Helpers ──────────────────────────────────────────────────────────
+
+    def coerce(input)
+      input.is_a?(Identifier) ? input : Parser.parse(input)
+    end
+
+    def urn_parts(iri)
+      return [] unless iri.nss
+      iri.nss.include?(":") ? iri.nss.split(":", 2) : [iri.nss]
+    end
+
+    def collect_notes(evidence)
+      evidence.flat_map(&:notes)
+    end
+
+    def find_evidence(evidence, source:)
+      evidence.find { |r| r.source == source }
+    end
+
+    def find_payload(evidence, rule)
+      r = evidence.find { |e| e.source == :policy && e.payload[:rule] == rule }
+      r&.payload
+    end
+
+    def would_be_hint(segments, idx, type, classifier)
+      return nil if idx.zero?
+
+      prev = segments[idx - 1]
+      return nil unless classifier.classify(prev) == :literal
+
+      base   = Inflector.singularize(prev)
+      suffix = type == :uuid ? "_uuid" : "_id"
+      "#{base}#{suffix}"
+    end
+  end
+end

data/lib/iriq/version.rb

@@ -1,3 +1,3 @@
 module Iriq
-  VERSION = "0.2.0"
+  VERSION = "0.33.0"
 end

data/lib/iriq.rb

@@ -3,16 +3,33 @@ require "iriq/errors"
 require "iriq/inflector"
 require "iriq/identifier"
 require "iriq/parser"
+require "iriq/specificity"
+require "iriq/recognizer"
+require "iriq/recognizers/uuid"
+require "iriq/recognizers/date"
+require "iriq/recognizers/integer"
 require "iriq/segment_classifier"
 require "iriq/segment_hints"
+require "iriq/shape"
 require "iriq/path_shape"
 require "iriq/normalizer"
 require "iriq/explanation"
+require "iriq/evidence"
+require "iriq/trace"
 require "iriq/cluster"
 require "iriq/clusterer"
 require "iriq/position_stats"
+require "set"
+
 require "iriq/observation"
+require "iriq/position"
+require "iriq/event"
+require "iriq/reducer"
+require "iriq/registrable_domain"
 require "iriq/storage"
+require "iriq/recognizer_proposal"
+require "iriq/synthesized_recognizer"
+require "iriq/cross_host_shape"
 require "iriq/corpus"
 require "iriq/extractor"
 require "iriq/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iriq
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.33.0
 platform: ruby
 authors:
 - Daniel Pepper
@@ -86,12 +86,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CLAUDE.md
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
-- Makefile
 - README.md
+- completions/_iriq
+- completions/iriq.bash
 - exe/iriq
 - iriq.gemspec
 - lib/iriq.rb
@@ -99,7 +97,10 @@ files:
 - lib/iriq/cluster.rb
 - lib/iriq/clusterer.rb
 - lib/iriq/corpus.rb
+- lib/iriq/cross_host_shape.rb
 - lib/iriq/errors.rb
+- lib/iriq/event.rb
+- lib/iriq/evidence.rb
 - lib/iriq/explanation.rb
 - lib/iriq/extractor.rb
 - lib/iriq/identifier.rb
@@ -108,13 +109,25 @@ files:
 - lib/iriq/observation.rb
 - lib/iriq/parser.rb
 - lib/iriq/path_shape.rb
+- lib/iriq/position.rb
 - lib/iriq/position_stats.rb
+- lib/iriq/recognizer.rb
+- lib/iriq/recognizer_proposal.rb
+- lib/iriq/recognizers/date.rb
+- lib/iriq/recognizers/integer.rb
+- lib/iriq/recognizers/uuid.rb
+- lib/iriq/reducer.rb
+- lib/iriq/registrable_domain.rb
 - lib/iriq/segment_classifier.rb
 - lib/iriq/segment_hints.rb
+- lib/iriq/shape.rb
+- lib/iriq/specificity.rb
 - lib/iriq/storage.rb
 - lib/iriq/storage/json.rb
 - lib/iriq/storage/memory.rb
 - lib/iriq/storage/sqlite.rb
+- lib/iriq/synthesized_recognizer.rb
+- lib/iriq/trace.rb
 - lib/iriq/version.rb
 homepage: https://github.com/dpep/iriq
 licenses:
@@ -127,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/CLAUDE.md

@@ -1,121 +0,0 @@
-# Iriq development conventions
-
-## Repo layout — Ruby and Go intermixed at the root
-
-We chose to mix Ruby and Go at the repo root rather than nest the Go module
-under `/go/`. The signal is "both implementations are peers, not one-is-primary."
-
-```
-iriq/
-  lib/ exe/ spec/      ← Ruby gem (library, CLI, specs)
-  iriq.gemspec
-  Gemfile
-
-  go.mod               ← module github.com/dpep/iriq
-  *.go                 ← Go package `iriq` at the root
-  cmd/iriq/            ← Go CLI binary
-  bin/                 ← built Go binary (gitignored)
-
-  script/              ← shared dev scripts (fixture gen, parity, benches)
-  spec/fixtures/       ← golden JSON shared by Ruby specs + Go tests
-  .github/workflows/   ← Ruby CI, Go CI, parity CI
-```
-
-Trade-offs of this layout:
-
-- Clean import path: `github.com/dpep/iriq` (no `/go/` artifact in consumers' code).
-- One version tag (`vX.Y.Z`) serves both runtimes — Ruby's gemspec and Go's
-  module use the same tag stream.
-- Root `ls` is busier (~15 `.go` files next to Ruby ones), accepted in exchange.
-- The gemspec explicitly excludes Go files so `gem build` doesn't ship them:
-  `git ls-files * ':!:spec' ':!:script' ':!:cmd' ':!:bin' ':!:*.go' ':!:go.mod' ':!:go.sum'`.
-
-## Building
-
-```sh
-# Ruby gem
-bundle install
-bundle exec exe/iriq --help     # runs the CLI from source
-
-# Go binary — convenience targets in the Makefile
-make build                      # → ./bin/iriq
-make install                    # go install into $GOBIN
-make uninstall                  # remove from $GOBIN
-make clean                      # remove ./bin/
-make test                       # go test ./...
-
-# Both via Homebrew
-brew install dpep/tools/iriq    # uses the Ruby gem under the hood
-```
-
-## Keeping Ruby and Go in sync
-
-The Ruby gem is the **reference implementation**. Go mirrors its public API
-and behavior. Two layers of parity testing keep them aligned:
-
-1. **Golden JSON fixtures** (`spec/fixtures/*.json`)
-   Generated by `script/generate_fixtures.rb` from the Ruby implementation
-   over a curated set of inputs. Go's `fixtures_test.go` loads each file
-   and asserts the same outputs from the Go side.
-
-2. **CLI parity harness** (`script/cli_parity.sh`)
-   Runs the same input through `bundle exec exe/iriq` and the Go binary and
-   diffs stdout. Lives in CI as the `Ruby ↔ Go parity` job.
-
-When changing behavior:
-
-1. Update the Ruby code + specs first.
-2. Regenerate fixtures: `bundle exec ruby script/generate_fixtures.rb`.
-3. Port the change to Go.
-4. `go test ./...` (uses the updated fixtures).
-5. `script/cli_parity.sh` should pass.
-6. Commit fixtures with the change — CI will fail if they're stale.
-
-## Tests
-
-```sh
-bundle exec rspec        # Ruby suite (305+ examples)
-go test ./...            # Go suite (native + fixture parity tests)
-script/cli_parity.sh     # CLI parity (13+ scenarios)
-```
-
-## Releases
-
-- One version tag covers both runtimes — bump `lib/iriq/version.rb` (and
-  optionally a matching constant on the Go side if we add one), tag `vX.Y.Z`,
-  push.
-- `gem push iriq-X.Y.Z.gem` to publish to RubyGems.
-- Update `Formula/iriq.rb` in the homebrew-tools tap to the new version.
-- Go consumers pick up the tag automatically via `go get @vX.Y.Z`.
-
-## Corpus storage backends
-
-The `Corpus` class delegates state to a `Storage` backend; three backends ship:
-
-- **Memory** — default, in-process only.
-- **JSON** — Memory wrapped with atomic load/save against a JSON file
-  (`.json` by default). Same shape both runtimes have always written.
-- **SQLite** — incremental UPSERTs against a `.db` / `.sqlite` / `.sqlite3`
-  file with WAL journaling. Supports concurrent observers and avoids
-  loading the whole corpus into memory.
-
-`Corpus.open(path)` (Ruby) / `iriq.OpenCorpus(path)` (Go) picks the backend
-by file extension. `corpus.save(other_path)` exports as JSON regardless of
-the live backend; `corpus.save(same_path)` is idempotent (no clobbering a
-SQLite file with JSON, etc.).
-
-The Ruby `sqlite3` gem is loaded lazily (only when a `.db` path is opened),
-keeping the iriq install footprint minimal for users that stick with JSON.
-On the Go side we use `modernc.org/sqlite` (pure Go — no cgo).
-
-When adding a new backend, replicate the contract in both languages and
-add a parity scenario in `script/cli_parity.sh`'s `corpus_pair` section.
-
-## What lives where in scripts
-
-- `script/benchmark.rb` — Ruby-only throughput benchmark.
-- `script/memory.rb` — Ruby-only memory profile.
-- `script/generate_fixtures.rb` — produces `spec/fixtures/*.json` for cross-runtime parity.
-- `script/cli_parity.sh` — Ruby ↔ Go CLI diff.
-- `script/bench_compare.sh` — Ruby vs Go CLI wall-time comparison.
-- `script/bench_storage.sh` — JSON vs SQLite backend timing (single-process, incremental, concurrent).

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/Gemfile.lock

@@ -1,103 +0,0 @@
-PATH
-  remote: .
-  specs:
-    iriq (0.2.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    date (3.5.1)
-    debug (1.11.1)
-      irb (~> 1.10)
-      reline (>= 0.3.8)
-    diff-lcs (1.6.2)
-    docile (1.4.1)
-    erb (6.0.4)
-    io-console (0.8.2)
-    irb (1.17.0)
-      pp (>= 0.6.0)
-      prism (>= 1.3.0)
-      rdoc (>= 4.0.0)
-      reline (>= 0.4.2)
-    mini_portile2 (2.8.9)
-    pp (0.6.3)
-      prettyprint
-    prettyprint (0.2.0)
-    prism (1.9.0)
-    psych (5.3.1)
-      date
-      stringio
-    rdoc (7.2.0)
-      erb
-      psych (>= 4.0.0)
-      tsort
-    reline (0.6.3)
-      io-console (~> 0.5)
-    rspec (3.13.2)
-      rspec-core (~> 3.13.0)
-      rspec-expectations (~> 3.13.0)
-      rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.6)
-      rspec-support (~> 3.13.0)
-    rspec-debugging (0.0.4)
-      rspec-expectations (>= 3)
-    rspec-expectations (3.13.5)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.8)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-support (3.13.7)
-    simplecov (0.22.0)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.2)
-    simplecov_json_formatter (0.1.4)
-    sqlite3 (2.9.4)
-      mini_portile2 (~> 2.8.0)
-    stringio (3.2.0)
-    tsort (0.2.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  debug (>= 1)
-  iriq!
-  rspec (>= 3.10)
-  rspec-debugging
-  simplecov (>= 0.22)
-  sqlite3 (>= 1.6)
-
-CHECKSUMS
-  date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0
-  debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6
-  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
-  docile (1.4.1) sha256=96159be799bfa73cdb721b840e9802126e4e03dfc26863db73647204c727f21e
-  erb (6.0.4) sha256=38e3803694be357fe2bfe312487c74beaf9fb4e5beb3e22498952fe1645b95d9
-  io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
-  irb (1.17.0) sha256=168c4ddb93d8a361a045c41d92b2952c7a118fa73f23fe14e55609eb7a863aae
-  iriq (0.2.0)
-  mini_portile2 (2.8.9) sha256=0cd7c7f824e010c072e33f68bc02d85a00aeb6fce05bb4819c03dfd3c140c289
-  pp (0.6.3) sha256=2951d514450b93ccfeb1df7d021cae0da16e0a7f95ee1e2273719669d0ab9df6
-  prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193
-  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
-  psych (5.3.1) sha256=eb7a57cef10c9d70173ff74e739d843ac3b2c019a003de48447b2963d81b1974
-  rdoc (7.2.0) sha256=8650f76cd4009c3b54955eb5d7e3a075c60a57276766ebf36f9085e8c9f23192
-  reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835
-  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
-  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
-  rspec-debugging (0.0.4) sha256=7a8e2dc240c140f0ed27b452a5661a56474ee8cf7b84c5bcbefd827ad36f0a6f
-  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
-  rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
-  rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
-  simplecov (0.22.0) sha256=fe2622c7834ff23b98066bb0a854284b2729a569ac659f82621fc22ef36213a5
-  simplecov-html (0.13.2) sha256=bd0b8e54e7c2d7685927e8d6286466359b6f16b18cb0df47b508e8d73c777246
-  simplecov_json_formatter (0.1.4) sha256=529418fbe8de1713ac2b2d612aa3daa56d316975d307244399fa4838c601b428
-  sqlite3 (2.9.4) sha256=6161c5b9c17886b289558e6c8082b28a22a814736d2433c9a67f4c6bfcde5c97
-  stringio (3.2.0) sha256=c37cb2e58b4ffbd33fe5cd948c05934af997b36e0b6ca6fdf43afa234cf222e1
-  tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
-
-BUNDLED WITH
-  4.0.9