free_zipcode_data 1.0.6 → 1.2.0

data/spec/free_zipcode_data/sqlite_ram_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'free_zipcode_data/sqlite_ram'
+
+RSpec.describe SqliteRam do
+  let(:tmpdir) { Dir.mktmpdir('sqlite_ram_test') }
+  let(:db_path) { File.join(tmpdir, 'test_db.sqlite3') }
+  let(:sqlite_ram) { described_class.new(db_path) }
+
+  after do
+    FileUtils.rm_rf(tmpdir)
+  end
+
+  describe '#initialize' do
+    it 'creates an in-memory database connection' do
+      expect(sqlite_ram.conn).to be_a(SQLite3::Database)
+    end
+
+    it 'stores the filename' do
+      expect(sqlite_ram.filename).to eq(db_path)
+    end
+  end
+
+  describe '#save_to_disk' do
+    it 'persists in-memory data to the file database' do
+      sqlite_ram.conn.execute('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)')
+      sqlite_ram.conn.execute("INSERT INTO test (name) VALUES ('hello')")
+      sqlite_ram.save_to_disk
+
+      file_db = SQLite3::Database.new(db_path)
+      rows = file_db.execute('SELECT name FROM test')
+      expect(rows).to eq([['hello']])
+      file_db.close
+    end
+  end
+
+  describe '#dump_tables' do
+    it 'exports each table to a CSV file in the given directory' do
+      sqlite_ram.conn.execute('CREATE TABLE widgets (id INTEGER PRIMARY KEY, name TEXT, weight REAL)')
+      sqlite_ram.conn.execute("INSERT INTO widgets (name, weight) VALUES ('gear', 1.5)")
+      sqlite_ram.conn.execute("INSERT INTO widgets (name, weight) VALUES ('bolt', 0.3)")
+
+      sqlite_ram.dump_tables(tmpdir)
+
+      csv_path = File.join(tmpdir, 'widgets.csv')
+      expect(File.exist?(csv_path)).to be true
+
+      csv = CSV.read(csv_path)
+      expect(csv[0]).to eq(%w[id name weight])
+      expect(csv.length).to eq(3) # header + 2 rows
+    end
+
+    it 'exports multiple tables' do
+      sqlite_ram.conn.execute('CREATE TABLE a (id INTEGER PRIMARY KEY)')
+      sqlite_ram.conn.execute('CREATE TABLE b (id INTEGER PRIMARY KEY)')
+
+      sqlite_ram.dump_tables(tmpdir)
+
+      expect(File.exist?(File.join(tmpdir, 'a.csv'))).to be true
+      expect(File.exist?(File.join(tmpdir, 'b.csv'))).to be true
+    end
+  end
+end

data/spec/free_zipcode_data/state_table_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'free_zipcode_data/state_table'
+
+RSpec.describe FreeZipcodeData::StateTable do
+  let(:db) { create_test_database(line_count: 5) }
+  let(:table) { described_class.new(database: db, tablename: 'states') }
+
+  before do
+    seed_countries(db)
+    table.build
+  end
+
+  describe '#build' do
+    it 'creates the states table' do
+      tables = db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='states'")
+      expect(tables.length).to eq(1)
+    end
+
+    it 'creates the unique_state index' do
+      indexes = db.execute("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='states'")
+      index_names = indexes.map(&:first)
+      expect(index_names).to include('unique_state')
+    end
+
+    it 'creates the state_name index' do
+      indexes = db.execute("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='states'")
+      index_names = indexes.map(&:first)
+      expect(index_names).to include('state_name')
+    end
+
+    it 'creates columns for country_id, abbr, and name' do
+      columns = db.execute("PRAGMA table_info('states')").map { |c| c[1] }
+      expect(columns).to include('country_id', 'abbr', 'name')
+    end
+  end
+
+  describe '#write' do
+    it 'inserts a state row' do
+      table.write({ country: 'US', short_state: 'NY', state: 'New York' })
+      rows = db.execute('SELECT abbr, name FROM states')
+      expect(rows.length).to eq(1)
+      expect(rows[0]).to eq(['NY', 'New York'])
+    end
+
+    it 'links the state to its country' do
+      table.write({ country: 'US', short_state: 'NY', state: 'New York' })
+      country_id = db.execute("SELECT id FROM countries WHERE alpha2 = 'US'")[0][0]
+      state_country_id = db.execute('SELECT country_id FROM states')[0][0]
+      expect(state_country_id).to eq(country_id)
+    end
+
+    it 'creates a state from country lookup when short_state is nil' do
+      row = { country: 'US', short_state: nil, state: 'Unknown' }
+      table.write(row)
+      rows = db.execute("SELECT abbr, name FROM states WHERE abbr = 'US'")
+      expect(rows.length).to eq(1)
+      expect(rows[0]).to eq(['US', 'United States of America'])
+      # Verify row mutation for downstream Kiba destinations
+      expect(row[:short_state]).to eq('US')
+      expect(row[:state]).to eq('United States of America')
+    end
+
+    it 'creates a state from country lookup when short_state is empty' do
+      table.write({ country: 'US', short_state: '', state: 'Unknown' })
+      rows = db.execute("SELECT abbr, name FROM states WHERE abbr = 'US'")
+      expect(rows.length).to eq(1)
+      expect(rows[0]).to eq(['US', 'United States of America'])
+    end
+
+    it 'returns nil when short_state is nil and country is unknown' do
+      result = table.write({ country: 'ZZ', short_state: nil, state: 'Unknown' })
+      expect(result).to be_nil
+      rows = db.execute('SELECT COUNT(*) FROM states')
+      expect(rows[0][0]).to eq(0)
+    end
+
+    it 'returns nil when country is not in the countries table' do
+      result = table.write({ country: 'DE', short_state: 'BY', state: 'Bavaria' })
+      expect(result).to be_nil
+      rows = db.execute('SELECT COUNT(*) FROM states')
+      expect(rows[0][0]).to eq(0)
+    end
+
+    it 'silently ignores duplicate state entries' do
+      table.write({ country: 'US', short_state: 'NY', state: 'New York' })
+      expect { table.write({ country: 'US', short_state: 'NY', state: 'New York' }) }.not_to raise_error
+      rows = db.execute('SELECT COUNT(*) FROM states')
+      expect(rows[0][0]).to eq(1)
+    end
+
+    it 'handles the Marshall Islands edge case' do
+      table.write({ country: 'US', short_state: 'MH', state: nil })
+      rows = db.execute("SELECT name FROM states WHERE abbr = 'MH'")
+      expect(rows[0][0]).to eq('Marshall Islands')
+    end
+
+    it 'handles state names with single quotes' do
+      # Some international state names can have apostrophes
+      table.write({ country: 'US', short_state: 'TX', state: "Cote d'Ivoire" })
+      rows = db.execute("SELECT name FROM states WHERE abbr = 'TX'")
+      expect(rows[0][0]).to eq("Cote d'Ivoire")
+    end
+
+    it 'allows states with the same name in different countries' do
+      table.write({ country: 'US', short_state: 'BC', state: 'British Columbia' })
+      table.write({ country: 'CA', short_state: 'BC', state: 'British Columbia' })
+      rows = db.execute("SELECT COUNT(*) FROM states WHERE name = 'British Columbia'")
+      expect(rows[0][0]).to eq(2)
+    end
+  end
+end

data/spec/free_zipcode_data/zipcode_table_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'free_zipcode_data/zipcode_table'
+
+RSpec.describe FreeZipcodeData::ZipcodeTable do
+  let(:db) { create_test_database(line_count: 5) }
+  let(:table) { described_class.new(database: db, tablename: 'zipcodes') }
+
+  before do
+    seed_countries(db)
+    seed_states(db)
+    table.build
+  end
+
+  describe '#build' do
+    it 'creates the zipcodes table' do
+      tables = db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='zipcodes'")
+      expect(tables.length).to eq(1)
+    end
+
+    it 'creates the unique_zipcode index' do
+      indexes = db.execute("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='zipcodes'")
+      index_names = indexes.map(&:first)
+      expect(index_names).to include('unique_zipcode')
+    end
+
+    it 'creates columns for code, state_id, city, area_code, lat, lon, accuracy' do
+      columns = db.execute("PRAGMA table_info('zipcodes')").map { |c| c[1] }
+      expect(columns).to include('code', 'state_id', 'city', 'area_code', 'lat', 'lon', 'accuracy')
+    end
+  end
+
+  describe '#write' do
+    let(:row) do
+      {
+        country: 'US',
+        postal_code: '60601',
+        short_state: 'IL',
+        state: 'Illinois',
+        city: 'Chicago',
+        latitude: '41.8819',
+        longitude: '-87.6278',
+        accuracy: '4'
+      }
+    end
+
+    it 'inserts a zipcode row' do
+      table.write(row)
+      rows = db.execute('SELECT code, city FROM zipcodes')
+      expect(rows.length).to eq(1)
+      expect(rows[0]).to eq(%w[60601 Chicago])
+    end
+
+    it 'stores latitude and longitude' do
+      table.write(row)
+      rows = db.execute('SELECT lat, lon FROM zipcodes')
+      expect(rows[0][0].to_s).to start_with('41.88')
+      expect(rows[0][1].to_s).to start_with('-87.62')
+    end
+
+    it 'links the zipcode to its state' do
+      table.write(row)
+      state_id = db.execute("SELECT id FROM states WHERE abbr = 'IL'")[0][0]
+      zipcode_state_id = db.execute('SELECT state_id FROM zipcodes')[0][0]
+      expect(zipcode_state_id.to_i).to eq(state_id)
+    end
+
+    it 'returns nil and skips when postal_code is nil' do
+      result = table.write(row.merge(postal_code: nil))
+      expect(result).to be_nil
+      rows = db.execute('SELECT COUNT(*) FROM zipcodes')
+      expect(rows[0][0]).to eq(0)
+    end
+
+    it 'returns nil and skips when state cannot be found' do
+      result = table.write(row.merge(short_state: 'ZZ', state: 'Nonexistent'))
+      expect(result).to be_nil
+      rows = db.execute('SELECT COUNT(*) FROM zipcodes')
+      expect(rows[0][0]).to eq(0)
+    end
+
+    it 'silently ignores duplicate zipcode entries' do
+      table.write(row)
+      expect { table.write(row) }.not_to raise_error
+      rows = db.execute('SELECT COUNT(*) FROM zipcodes')
+      expect(rows[0][0]).to eq(1)
+    end
+
+    it 'handles city names with single quotes' do
+      table.write(row.merge(city: "Coeur d'Alene", postal_code: '83814'))
+      rows = db.execute('SELECT city FROM zipcodes')
+      expect(rows[0][0]).to eq("Coeur d'Alene")
+    end
+
+    it 'inserts multiple different zipcodes' do
+      table.write(row)
+      table.write(row.merge(postal_code: '10001', city: 'New York', short_state: 'NY', state: 'New York'))
+      rows = db.execute('SELECT COUNT(*) FROM zipcodes')
+      expect(rows[0][0]).to eq(2)
+    end
+  end
+end

data/spec/free_zipcode_data_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe FreeZipcodeData do
+  describe '.root' do
+    it 'returns a Pathname to the project root' do
+      expect(described_class.root).to be_a(Pathname)
+      expect(described_class.root.join('lib', 'free_zipcode_data.rb')).to exist
+    end
+  end
+
+  describe '.current_environment' do
+    it 'returns "test" when APP_ENV is set to test' do
+      expect(described_class.current_environment).to eq('test')
+    end
+
+    it 'defaults to "development" when APP_ENV is not set' do
+      allow(ENV).to receive(:fetch).with('APP_ENV', 'development').and_return('development')
+      expect(described_class.current_environment).to eq('development')
+    end
+  end
+
+  describe '.config_file' do
+    it 'returns spec/fixtures path in test environment' do
+      path = described_class.config_file
+      expect(path.to_s).to include('spec/fixtures/.free_zipcode_data.yml')
+    end
+  end
+
+  describe '.os' do
+    it 'returns :normal on non-Windows platforms' do
+      expect(described_class.os).to eq(:normal)
+    end
+  end
+
+  it 'has a version number' do
+    expect(FreeZipcodeData::VERSION).to match(/\A\d+\.\d+\.\d+\z/)
+  end
+end

data/spec/spec_helper.rb

@@ -2,11 +2,32 @@
 
 ENV['APP_ENV'] = 'test'
 
-require 'pry'
+begin
+  require 'pry'
+rescue NameError, LoadError
+  # pry may not be compatible with current Ruby version
+end
+
+require 'ostruct'
+require 'free_zipcode_data'
+require 'free_zipcode_data/runner'
 
-Dir[Pathname.new(File.dirname(__FILE__)).parent.join('spec/support/**/*.rb')].sort.each { |f| require f }
+Dir[Pathname.new(File.dirname(__FILE__)).parent.join('spec/support/**/*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
+  config.include DatabaseHelpers
+
+  # Silence progress bar and logger output during tests
+  config.before do
+    allow(ProgressBar).to receive(:create).and_wrap_original do |method, **args|
+      method.call(**args, output: StringIO.new)
+    end
+    FreeZipcodeData::Logger.instance.log_provider = Logger.new(StringIO.new)
+    FreeZipcodeData::Options.instance.initialize_hash(
+      OpenStruct.new(verbose: false)
+    )
+  end
+
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end

data/spec/support/database_helpers.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+
+module DatabaseHelpers
+  def create_test_database(line_count: 5)
+    db = SQLite3::Database.new(':memory:')
+    db.execute_batch(<<-SQL)
+      CREATE TABLE meta (
+        id integer not null primary key,
+        name varchar(255),
+        value varchar(255)
+      )
+    SQL
+    db.execute("INSERT INTO meta (name, value) VALUES ('line_count', #{line_count})")
+    db
+  end
+
+  def seed_countries(db, tablename: 'countries')
+    table = FreeZipcodeData::CountryTable.new(database: db, tablename: tablename)
+    table.build
+    [
+      { country: 'US' },
+      { country: 'CA' },
+      { country: 'GB' }
+    ].each { |row| table.write(row) }
+  end
+
+  def seed_states(db, tablename: 'states')
+    table = FreeZipcodeData::StateTable.new(database: db, tablename: tablename)
+    table.build
+    [
+      { country: 'US', short_state: 'NY', state: 'New York' },
+      { country: 'US', short_state: 'CA', state: 'California' },
+      { country: 'US', short_state: 'IL', state: 'Illinois' }
+    ].each { |row| table.write(row) }
+  end
+
+  def seed_counties(db, tablename: 'counties')
+    table = FreeZipcodeData::CountyTable.new(database: db, tablename: tablename)
+    table.build
+    [
+      { country: 'US', county: 'New York', short_county: '061', short_state: 'NY', state: 'New York' },
+      { country: 'US', county: 'Los Angeles', short_county: '037', short_state: 'CA', state: 'California' },
+      { country: 'US', county: 'Cook', short_county: '031', short_state: 'IL', state: 'Illinois' }
+    ].each { |row| table.write(row) }
+  end
+end

metadata

@@ -1,80 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: free_zipcode_data
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.2.0
 platform: ruby
 authors:
 - Chris Blackburn
 - Chris McKnight
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-09-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !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: rspec
+  name: colored
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
-  type: :development
+        version: '1.2'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: csv
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -82,61 +39,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-prof
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.17'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.17'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-- !ruby/object:Gem::Dependency
-  name: colored
+  name: kiba
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: kiba
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: optimist
   requirement: !ruby/object:Gem::Requirement
@@ -204,13 +133,16 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".dockerignore"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
 - CHANGELOG
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - ISSUE_TEMPLATE.md
@@ -225,6 +157,7 @@ files:
 - bin/free_zipcode_data
 - counties_states_zipcodes.sql
 - country_lookup_table.yml
+- docker-entrypoint.sh
 - free_zipcode_data.gemspec
 - lib/etl/common.rb
 - lib/etl/csv_source.rb
@@ -242,13 +175,31 @@ files:
 - lib/free_zipcode_data/version.rb
 - lib/free_zipcode_data/zipcode_table.rb
 - lib/tasks/version.rake
+- spec/etl/csv_source_spec.rb
+- spec/etl/free_zipcode_data_job_spec.rb
+- spec/fixtures/.free_zipcode_data.yml
+- spec/fixtures/US.txt
+- spec/fixtures/US.zip
+- spec/fixtures/test_data.csv
+- spec/fixtures/test_data.txt
+- spec/free_zipcode_data/country_table_spec.rb
+- spec/free_zipcode_data/county_table_spec.rb
+- spec/free_zipcode_data/data_source_spec.rb
+- spec/free_zipcode_data/db_table_spec.rb
+- spec/free_zipcode_data/logger_spec.rb
+- spec/free_zipcode_data/options_spec.rb
+- spec/free_zipcode_data/runner_spec.rb
+- spec/free_zipcode_data/sqlite_ram_spec.rb
+- spec/free_zipcode_data/state_table_spec.rb
+- spec/free_zipcode_data/zipcode_table_spec.rb
+- spec/free_zipcode_data_spec.rb
 - spec/spec_helper.rb
+- spec/support/database_helpers.rb
 homepage: https://github.com/midwire/free_zipcode_data
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -256,15 +207,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.2
+      version: 3.4.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Free US and world-wide postal codes in SQLite and CSV format
 test_files: []