jpzip 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f683058e4526a22c00c308de577f22b564c6f7f061453503198e85c4b0db51f
+  data.tar.gz: ec819d45358f48dbf25e0270ce7bde1b5d02b9aa0bdf7072ad83a1f639e3849a
+SHA512:
+  metadata.gz: 6651b29e75ad6b1c7530048e8a051c5851161ff35c65850cc24823dd9dc1190af7c70ceeaf13b996a48dff252cd68e6e773855619fa67b961a6a57d72d604934
+  data.tar.gz: b93fc8e3edf07e60c1f3f647331be79d304d96e7f8c3f32a2469cf6f9b3f9a12c1a8241fd2ec6eedb064692d130010b8d9d82844a8eda8256b4ef5db4f881117

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nadai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# jpzip — Ruby SDK
+
+> 日本の郵便番号を CDN 配信の JSON データから引く Ruby SDK。
+
+- 配信ドメイン: `https://jpzip.nadai.dev`
+- プロトコル仕様: [`jpzip/spec`](https://github.com/jpzip/spec)
+- データ ETL: [`jpzip/data`](https://github.com/jpzip/data)
+
+```ruby
+# Gemfile
+gem "jpzip"
+```
+
+または直接:
+
+```sh
+gem install jpzip
+```
+
+Ruby 3.2 以上が必要(`Data.define` を使用)。
+
+## 使い方
+
+### モジュール関数 API
+
+```ruby
+require "jpzip"
+
+entry = Jpzip.lookup("2310017")
+# entry == nil なら見つからなかった
+# entry.prefecture          #=> "神奈川県"
+# entry.city                #=> "横浜市中区"
+# entry.towns.first.town    #=> "本町"
+
+dict = Jpzip.lookup_group("23")  # 2 桁は 10 並列 fetch
+all  = Jpzip.lookup_all
+meta = Jpzip.meta
+
+Jpzip.valid_zipcode?("2310017")  #=> true
+Jpzip.valid_zipcode?("231-0017") #=> false
+```
+
+### クライアント API (L2 キャッシュ・複数インスタンス用)
+
+```ruby
+client = Jpzip::Client.new(
+  base_url: "https://jpzip.nadai.dev",
+  memory_cache_size: 200,
+  cache: my_cache,                       # Jpzip::Cache サブクラス
+  on_spec_mismatch: ->(expected, got) {
+    warn "jpzip spec mismatch: expected=#{expected} got=#{got}"
+  }
+)
+
+client.preload("all")
+entry = client.lookup("2310017")
+```
+
+## Cache インターフェース
+
+```ruby
+class MyFileCache < Jpzip::Cache
+  def get(key);           ...; end  # => String or nil
+  def set(key, value);    ...; end
+  def delete(key);        ...; end
+  def clear;              ...; end
+end
+```
+
+ファイル / Redis / Memcached 等の任意の実装を渡せる。L2 は明示的に有効化した場合のみ使われ、デフォルトは L1 (メモリ LRU) のみ。
+
+## 入力検証
+
+`Jpzip.lookup` は `\A\d{7}\z` にマッチしない入力に対して fetch せず `nil` を返す。
+
+## バージョン整合性
+
+`Jpzip.meta` 取得時、`spec_version` が SDK 対応バージョンと異なる場合 `on_spec_mismatch` コールバックが 1 度だけ呼ばれる。データバージョンが変わったら L1/L2 を自動 invalidate する。
+
+## 並列性とスレッドセーフ
+
+`Jpzip::Client` はスレッドセーフ。複数スレッドから同一インスタンスを共有しても安全。`lookup_group("23")` や `lookup_all` は内部で `Thread` を使って並列 fetch する。
+
+## 依存
+
+なし。Ruby 標準ライブラリ (`net/http`, `json`, `monitor`) のみ使用。
+
+## ライセンス
+
+[MIT](./LICENSE)

data/jpzip.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/jpzip/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "jpzip"
+  spec.version       = Jpzip::VERSION
+  spec.authors       = ["nadai"]
+  spec.email         = ["noreply@nadai.dev"]
+
+  spec.summary       = "Ruby SDK for the jpzip Japanese postal-code dataset"
+  spec.description   = "jpzip は日本の郵便番号を CDN 配信の JSON データから引く Ruby SDK。" \
+                       "L1 LRU メモリキャッシュを内蔵し、任意の L2 永続キャッシュを差し込める。"
+  spec.homepage      = "https://github.com/jpzip/ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata = {
+    "homepage_uri"      => spec.homepage,
+    "source_code_uri"   => "https://github.com/jpzip/ruby",
+    "bug_tracker_uri"   => "https://github.com/jpzip/ruby/issues",
+    "documentation_uri" => "https://github.com/jpzip/ruby",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "README.md",
+    "LICENSE",
+    "jpzip.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  # No runtime dependencies — net/http and json ship with Ruby.
+
+  spec.add_development_dependency "minitest", "~> 5.20"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "webmock", "~> 3.20"
+end

data/lib/jpzip/cache.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Jpzip
+  # Cache is the abstract interface a user-supplied L2 persistent cache must
+  # satisfy. Implementations are free to add TTLs, eviction, or backends
+  # (file, Redis, IndexedDB-equivalent, etc.).
+  #
+  # Subclasses MUST override every method below.
+  class Cache
+    # Get the bytes stored under +key+, or nil if absent.
+    def get(key)
+      raise NotImplementedError, "#{self.class}#get must be implemented"
+    end
+
+    # Set +value+ (a String of bytes) under +key+.
+    def set(key, value)
+      raise NotImplementedError, "#{self.class}#set must be implemented"
+    end
+
+    # Delete the entry stored under +key+ (no-op if absent).
+    def delete(key)
+      raise NotImplementedError, "#{self.class}#delete must be implemented"
+    end
+
+    # Clear every entry in the cache.
+    def clear
+      raise NotImplementedError, "#{self.class}#clear must be implemented"
+    end
+  end
+
+  # MemoryLRU is the L1 in-memory cache, bounded by a fixed number of prefix
+  # entries. It is safe for concurrent use.
+  class MemoryLRU
+    DEFAULT_CAPACITY = 100
+
+    def initialize(capacity = DEFAULT_CAPACITY)
+      @capacity = capacity < 1 ? 1 : capacity
+      # Ruby's Hash preserves insertion order, so it doubles as an LRU index:
+      # touch on read by deleting + re-inserting at the tail.
+      @items = {}
+      @mu = Monitor.new
+    end
+
+    def get(key)
+      @mu.synchronize do
+        return nil unless @items.key?(key)
+
+        value = @items.delete(key)
+        @items[key] = value
+        value
+      end
+    end
+
+    def set(key, value)
+      @mu.synchronize do
+        @items.delete(key) if @items.key?(key)
+        @items[key] = value
+        @items.shift while @items.size > @capacity
+        nil
+      end
+    end
+
+    def delete(key)
+      @mu.synchronize { @items.delete(key) }
+    end
+
+    def clear
+      @mu.synchronize { @items.clear }
+      nil
+    end
+
+    def size
+      @mu.synchronize { @items.size }
+    end
+  end
+end

data/lib/jpzip/client.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "json"
+require "monitor"
+
+require_relative "cache"
+require_relative "http"
+require_relative "types"
+require_relative "version"
+
+module Jpzip
+  ZIP_REGEX = /\A\d{7}\z/.freeze
+  PREFIX_REGEX = /\A\d{1,3}\z/.freeze
+
+  # InvalidPrefixError is raised when LookupGroup/Preload receive a prefix
+  # that is not 1-3 digits.
+  class InvalidPrefixError < ArgumentError; end
+
+  # Client is the jpzip SDK entry point. Construct it once and reuse it
+  # across threads — it is safe for concurrent use.
+  class Client
+    # @param base_url [String] override the CDN origin
+    # @param cache [Jpzip::Cache, nil] optional L2 persistent cache
+    # @param memory_cache_size [Integer] L1 LRU capacity in prefix entries
+    # @param on_spec_mismatch [Proc, nil] hook invoked once when /meta.json's
+    #   spec_version differs from {Jpzip::SPEC_VERSION}
+    # @param http_client [Proc, nil] testing hook receiving a URI, returning
+    #   a Net::HTTPResponse-like object
+    def initialize(base_url: DEFAULT_BASE_URL,
+                   cache: nil,
+                   memory_cache_size: MemoryLRU::DEFAULT_CAPACITY,
+                   on_spec_mismatch: nil,
+                   http_client: nil)
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @cache = cache
+      @mem = MemoryLRU.new(memory_cache_size)
+      @on_spec_mismatch = on_spec_mismatch
+      @http_client = http_client
+      @meta_mu = Monitor.new
+      @meta_cached = nil
+      @meta_resolved = false
+      @known_version = nil
+    end
+
+    # Lookup returns the ZipcodeEntry for +zipcode+ or nil if not found.
+    # Malformed input returns nil without contacting the network.
+    def lookup(zipcode)
+      return nil unless ZIP_REGEX.match?(zipcode.to_s)
+
+      dict = fetch_prefix_dict(zipcode[0, 3])
+      return nil if dict.nil?
+
+      dict[zipcode]
+    end
+
+    # LookupGroup fetches all entries under a 1-, 2-, or 3-digit prefix.
+    # A 2-digit prefix fans out into 10 parallel prefix-3 fetches.
+    #
+    # @return [Hash{String => Jpzip::ZipcodeEntry}]
+    def lookup_group(prefix)
+      prefix = prefix.to_s
+      raise InvalidPrefixError, "jpzip: prefix must be 1-3 digits, got #{prefix.inspect}" unless PREFIX_REGEX.match?(prefix)
+
+      case prefix.length
+      when 3
+        fetch_prefix_dict(prefix) || {}
+      when 1
+        fetch_url(group_url(prefix)) || {}
+      when 2
+        parallel_merge(0.upto(9).map { |i| "#{prefix}#{i}" }) { |p3| fetch_prefix_dict(p3) }
+      end
+    end
+
+    # LookupAll fans out across /g/0..9.json in parallel and merges. The CDN
+    # does not publish a single /all.json because the combined file exceeds
+    # Cloudflare Pages' 25 MiB per-file limit.
+    def lookup_all
+      parallel_merge(0.upto(9).map(&:to_s)) { |p1| fetch_url(group_url(p1)) }
+    end
+
+    # Meta returns the cached /meta.json. First call hits the network; later
+    # calls return the cached value until {#refresh} is invoked.
+    def meta
+      @meta_mu.synchronize do
+        return @meta_cached if @meta_resolved
+      end
+
+      result = Http.get("#{@base_url}/meta.json", http_client: @http_client)
+
+      @meta_mu.synchronize do
+        if result.status == 404
+          @meta_resolved = true
+          @meta_cached = nil
+          return nil
+        end
+
+        parsed = JSON.parse(result.body)
+        m = Meta.from_hash(parsed)
+
+        if m.spec_version != SPEC_VERSION && @on_spec_mismatch
+          @on_spec_mismatch.call(SPEC_VERSION, m.spec_version)
+        end
+
+        if @known_version && @known_version != m.version
+          @mem.clear
+          @cache&.clear
+        end
+
+        @known_version = m.version
+        @meta_cached = m
+        @meta_resolved = true
+        m
+      end
+    end
+
+    # Preload pulls the requested scope into L1 (and L2 when configured).
+    # +scope+ is either the string "all" or a 1-3 digit prefix.
+    def preload(scope)
+      scope = scope.to_s
+      if scope == "all"
+        dict = lookup_all
+        buckets = Hash.new { |h, k| h[k] = {} }
+        dict.each { |zip, entry| buckets[zip[0, 3]][zip] = entry }
+        buckets.each do |p, b|
+          url = prefix_url(p)
+          @mem.set(url, b)
+          write_l2(url, b)
+        end
+        return nil
+      end
+
+      raise InvalidPrefixError, "jpzip: prefix must be 1-3 digits, got #{scope.inspect}" unless PREFIX_REGEX.match?(scope)
+
+      lookup_group(scope)
+      nil
+    end
+
+    # Refresh wipes L1 (and L2 when configured) and forgets cached meta.
+    def refresh
+      @mem.clear
+      @meta_mu.synchronize do
+        @meta_cached = nil
+        @meta_resolved = false
+        @known_version = nil
+      end
+      @cache&.clear
+      nil
+    end
+
+    # @api private
+    def memory_cache_size
+      @mem.size
+    end
+
+    private
+
+    def prefix_url(prefix3)
+      "#{@base_url}/p/#{prefix3}.json"
+    end
+
+    def group_url(prefix1)
+      "#{@base_url}/g/#{prefix1}.json"
+    end
+
+    def fetch_prefix_dict(prefix3)
+      url = prefix_url(prefix3)
+      if (cached = @mem.get(url))
+        return cached
+      end
+
+      if (from_l2 = read_l2(url))
+        @mem.set(url, from_l2)
+        return from_l2
+      end
+
+      dict = fetch_url(url)
+      if dict
+        @mem.set(url, dict)
+        write_l2(url, dict)
+      end
+      dict
+    end
+
+    def fetch_url(url)
+      result = Http.get(url, http_client: @http_client)
+      return nil if result.status == 404
+
+      parsed = JSON.parse(result.body)
+      parsed.each_with_object({}) do |(zip, raw), out|
+        out[zip] = ZipcodeEntry.from_hash(raw)
+      end
+    end
+
+    def read_l2(url)
+      return nil unless @cache
+
+      bytes = @cache.get(url)
+      return nil if bytes.nil? || bytes.empty?
+
+      begin
+        parsed = JSON.parse(bytes)
+      rescue JSON::ParserError
+        @cache.delete(url)
+        return nil
+      end
+
+      parsed.each_with_object({}) do |(zip, raw), out|
+        out[zip] = ZipcodeEntry.from_hash(raw)
+      end
+    end
+
+    def write_l2(url, dict)
+      return unless @cache
+
+      payload = dict.each_with_object({}) do |(zip, entry), h|
+        h[zip] = entry.to_h
+      end
+      @cache.set(url, JSON.generate(payload))
+    end
+
+    # parallel_merge runs +block+ for each value in +items+ across up to 10
+    # threads, then merges the resulting hashes (nils skipped). Raises the
+    # first error if any thread fails.
+    def parallel_merge(items)
+      threads = items.map do |item|
+        Thread.new do
+          Thread.current.report_on_exception = false
+          yield(item)
+        end
+      end
+
+      results = threads.map(&:value)
+      results.each_with_object({}) do |dict, out|
+        next if dict.nil?
+
+        out.merge!(dict)
+      end
+    end
+  end
+end

data/lib/jpzip/http.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Jpzip
+  # Internal HTTP helpers. Pinned to the Ruby stdlib (net/http) so the gem
+  # has zero runtime dependencies.
+  module Http
+    MAX_ATTEMPTS = 3
+    BASE_BACKOFF = 0.2
+    DEFAULT_TIMEOUT = 30 # seconds
+
+    # Result wraps an HTTP response: +body+ (String or nil) and +status+ (Integer).
+    Result = Struct.new(:body, :status, keyword_init: true)
+
+    # Get fetches +url+ with bounded retries on 5xx / network failures.
+    #
+    # Returns a Result where +status+ is the HTTP status code. On 404 +body+
+    # is nil so callers can distinguish "absent" from "fetch error". On
+    # repeated failure this raises the last error encountered.
+    def self.get(url, http_client: nil, sleeper: nil)
+      uri = URI(url)
+      last_error = nil
+
+      MAX_ATTEMPTS.times do |attempt|
+        if attempt.positive?
+          delay = BASE_BACKOFF * (2**attempt)
+          (sleeper || method(:sleep)).call(delay)
+        end
+
+        begin
+          response = perform_request(uri, http_client)
+          status = response.code.to_i
+
+          return Result.new(body: nil, status: 404) if status == 404
+
+          if status >= 500
+            last_error = HttpError.new("jpzip: #{url} returned #{status}")
+            next
+          end
+
+          if status >= 400
+            raise HttpError, "jpzip: #{url} returned #{status}"
+          end
+
+          return Result.new(body: response.body, status: status)
+        rescue HttpError
+          raise
+        rescue StandardError => e
+          last_error = e
+          next
+        end
+      end
+
+      raise(last_error || HttpError.new("jpzip: #{url} failed after #{MAX_ATTEMPTS} attempts"))
+    end
+
+    def self.perform_request(uri, http_client)
+      if http_client
+        return http_client.call(uri)
+      end
+
+      Net::HTTP.start(
+        uri.host,
+        uri.port,
+        use_ssl: uri.scheme == "https",
+        open_timeout: DEFAULT_TIMEOUT,
+        read_timeout: DEFAULT_TIMEOUT
+      ) do |http|
+        req = Net::HTTP::Get.new(uri.request_uri)
+        req["Accept"] = "application/json"
+        req["Accept-Encoding"] = "gzip"
+        http.request(req)
+      end
+    end
+
+    # HttpError signals a non-retryable HTTP failure (4xx other than 404, or
+    # exhausted retries on 5xx).
+    class HttpError < StandardError; end
+  end
+end

data/lib/jpzip/types.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Jpzip
+  # Town corresponds to one element of ZipcodeEntry#towns.
+  #
+  # Fields match the JSON shape served by the CDN (snake_case).
+  Town = Data.define(:town, :kana, :roma, :note) do
+    # Build a Town from a parsed JSON hash. Unknown keys are ignored so the
+    # SDK keeps working when the protocol grows new optional fields.
+    def self.from_hash(h)
+      new(
+        town: h["town"] || "",
+        kana: h["kana"] || "",
+        roma: h["roma"] || "",
+        note: h["note"]
+      )
+    end
+
+    def to_h
+      base = { town: town, kana: kana, roma: roma }
+      base[:note] = note if note
+      base
+    end
+  end
+
+  # ZipcodeEntry is one logical entry as published by the CDN.
+  ZipcodeEntry = Data.define(
+    :prefecture,
+    :prefecture_kana,
+    :prefecture_roma,
+    :prefecture_code,
+    :city,
+    :city_kana,
+    :city_roma,
+    :city_code,
+    :towns
+  ) do
+    def self.from_hash(h)
+      new(
+        prefecture: h["prefecture"] || "",
+        prefecture_kana: h["prefecture_kana"] || "",
+        prefecture_roma: h["prefecture_roma"] || "",
+        prefecture_code: h["prefecture_code"] || "",
+        city: h["city"] || "",
+        city_kana: h["city_kana"] || "",
+        city_roma: h["city_roma"] || "",
+        city_code: h["city_code"] || "",
+        towns: (h["towns"] || []).map { |t| Town.from_hash(t) }
+      )
+    end
+  end
+
+  # Endpoints is part of /meta.json.
+  Endpoints = Data.define(:group, :prefix) do
+    def self.from_hash(h)
+      new(group: h["group"] || "", prefix: h["prefix"] || "")
+    end
+  end
+
+  # Meta is /meta.json.
+  Meta = Data.define(
+    :version,
+    :generated_at,
+    :spec_version,
+    :total_zipcodes,
+    :prefix_count,
+    :by_pref,
+    :data_source,
+    :endpoints
+  ) do
+    def self.from_hash(h)
+      new(
+        version: h["version"] || "",
+        generated_at: h["generated_at"] || "",
+        spec_version: h["spec_version"] || "",
+        total_zipcodes: h["total_zipcodes"] || 0,
+        prefix_count: h["prefix_count"] || 0,
+        by_pref: h["by_pref"] || {},
+        data_source: h["data_source"] || "",
+        endpoints: Endpoints.from_hash(h["endpoints"] || {})
+      )
+    end
+  end
+end

data/lib/jpzip/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jpzip
+  VERSION = "0.1.0"
+
+  # SpecVersion is the jpzip protocol version this SDK targets.
+  SPEC_VERSION = "1.0"
+
+  # DefaultBaseURL is the production CDN origin.
+  DEFAULT_BASE_URL = "https://jpzip.nadai.dev"
+end

data/lib/jpzip.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "jpzip/version"
+require_relative "jpzip/types"
+require_relative "jpzip/cache"
+require_relative "jpzip/http"
+require_relative "jpzip/client"
+
+# Jpzip is the Ruby SDK for the jpzip postal-code dataset
+# (https://jpzip.nadai.dev). The SDK fetches normalized JSON from the CDN,
+# keeps a per-prefix in-memory LRU, and optionally backs that with a
+# user-supplied persistent cache.
+module Jpzip
+  class << self
+    # Returns true iff +str+ is a syntactically valid 7-digit zipcode
+    # (no network call).
+    def valid_zipcode?(str)
+      ZIP_REGEX.match?(str.to_s)
+    end
+
+    # Convenience shortcuts delegating to a process-wide default Client.
+    # The singleton uses L1 only — for L2 caches construct your own Client.
+    def lookup(zipcode)
+      default_client.lookup(zipcode)
+    end
+
+    def lookup_group(prefix)
+      default_client.lookup_group(prefix)
+    end
+
+    def lookup_all
+      default_client.lookup_all
+    end
+
+    def preload(scope)
+      default_client.preload(scope)
+    end
+
+    def meta
+      default_client.meta
+    end
+
+    # Replace the singleton — mainly for tests.
+    def reset_default_client!
+      @default_client = nil
+    end
+
+    # Override the singleton with a configured Client. Useful when the app
+    # wants to share an L2 cache through the module-level helpers.
+    def configure(**opts)
+      @default_client = Client.new(**opts)
+    end
+
+    private
+
+    def default_client
+      @default_client ||= Client.new
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: jpzip
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- nadai
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.20'
+description: jpzip は日本の郵便番号を CDN 配信の JSON データから引く Ruby SDK。L1 LRU メモリキャッシュを内蔵し、任意の
+  L2 永続キャッシュを差し込める。
+email:
+- noreply@nadai.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- jpzip.gemspec
+- lib/jpzip.rb
+- lib/jpzip/cache.rb
+- lib/jpzip/client.rb
+- lib/jpzip/http.rb
+- lib/jpzip/types.rb
+- lib/jpzip/version.rb
+homepage: https://github.com/jpzip/ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jpzip/ruby
+  source_code_uri: https://github.com/jpzip/ruby
+  bug_tracker_uri: https://github.com/jpzip/ruby/issues
+  documentation_uri: https://github.com/jpzip/ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby SDK for the jpzip Japanese postal-code dataset
+test_files: []