zipcoder 0.1.0 → 0.2.0

data/lib/ext/integer.rb

@@ -1,8 +1,11 @@
 class Integer
 
   def zip_info(**kwargs)
-    string = self.to_s.rjust(5, '0')
-    string.zip_info(**kwargs)
+    Zipcoder.zip_info self, **kwargs
+  end
+
+  def to_zip
+    self.to_s.rjust(5, '0')
   end
 
 end

data/lib/ext/string.rb

@@ -3,32 +3,15 @@ require_relative "../zipcoder"
 class String
 
   def zip_info(**kwargs)
-    info = Zipcoder.zip_lookup[self]
-
-    # Filter to the included keys
-    if kwargs[:keys] != nil
-      new_info = {}
-      kwargs[:keys].each { |k| new_info[k] = info[k] }
-      info = new_info
-    end
-
-    info
+    Zipcoder.zip_info self, **kwargs
   end
 
   def city_info(**kwargs)
-    # Cleanup "self"
-    key = self.delete(' ').upcase
-
-    info = Zipcoder.city_lookup[key]
-
-    # Filter to the included keys
-    if kwargs[:keys] != nil
-      new_info = {}
-      kwargs[:keys].each { |k| new_info[k] = info[k] }
-      info = new_info
-    end
+    Zipcoder.city_info self, **kwargs
+  end
 
-    info
+  def to_zip
+    self
   end
 
 end

data/lib/zipcoder/version.rb

@@ -1,3 +1,3 @@
 module Zipcoder
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/zipcoder.rb

@@ -6,27 +6,133 @@ require "yaml"
 module Zipcoder
 
   # Data Structure Load and Lookup
-  @@zip_lookup = nil
-  def self.zip_lookup
-    self.load_data if @@zip_lookup == nil
-    @@zip_lookup
+  @@zip_data = nil
+  def self.zip_data
+    self.load_data if @@zip_data == nil
+    @@zip_data
   end
 
-  @@city_lookup = nil
-  def self.city_lookup
-    self.load_data if @@city_lookup == nil
-    @@city_lookup
+  @@city_cache = {}
+  def self.city_cache
+    @@city_cache
   end
 
   # Loads the data into memory
   def self.load_data
     this_dir = File.expand_path(File.dirname(__FILE__))
 
-    zip_lookup = File.join(this_dir, 'data', 'zip_lookup.yml')
-    @@zip_lookup = YAML.load(File.open(zip_lookup))
+    zip_data = File.join(this_dir, 'data', 'zip_data.yml')
+    @@zip_data = YAML.load(File.open(zip_data))
+  end
+
+  # Looks up zip code information
+  def self.zip_info(zip=nil, **kwargs, &block)
+
+    # If zip is not nil, then we are returning a single value
+    if zip != nil
+      # Get the info
+      info = self.zip_data[zip.to_zip]
+
+      # Inform callback that we have a match
+      block.call(info) if block != nil
+
+      # Filter to the included keys
+      self._filter_hash_args info, kwargs[:keys]
+    else
+      # If zip is nil, then we are returning an array of values
+
+      infos = []
+      city_filter = kwargs[:city] != nil ? kwargs[:city].upcase : nil
+      state_filter = kwargs[:state] != nil ? kwargs[:state].upcase : nil
+
+      # Iterate through and only add the ones that match the filters
+      self.zip_data.values.each { |info|
+        if (city_filter == nil or info[:city] == city_filter) and
+            (state_filter == nil or info[:state] == state_filter)
+          infos << self._filter_hash_args(info, kwargs[:keys])
+
+          # Inform callback that we have a match
+          block.call(info) if block != nil
+        end
+      }
+
+      infos
+    end
+  end
+
+  # Looks up city information
+  def self.city_info(city_state, **kwargs)
+    unless city_state.include? ','
+      raise Exception, "city/state must include ','"
+    end
+
+    # Check the cache
+    cache_key = city_state.delete(' ').upcase
+    cached_value = self.city_cache[cache_key]
+    if cached_value != nil
+      return self._filter_hash_args cached_value, kwargs[:keys]
+    end
+
+    # Cleanup city/state
+    components = city_state.split(",")
+    city = components[0].strip.upcase
+    state = components[1].strip.upcase
+
+    # Normalize response
+    zip_min = 100000
+    zip_max = 0
+    lat_min = 200
+    lat_max = 0
+    long_min = 200
+    long_max = 0
+
+    # Get the infos associated with this city/state.  While
+    # getting those, store the min/max so we can create a
+    # normalized version of this object
+    infos = self.zip_info(city: city, state: state) do |info|
+      zip = info[:zip].to_i
+      zip_min = zip if zip < zip_min
+      zip_max = zip if zip > zip_max
+      lat_min = info[:lat] if info[:lat] < lat_min
+      lat_max = info[:lat] if info[:lat] > lat_max
+      long_min = info[:long] if info[:long] < long_min
+      long_max = info[:long] if info[:long] > long_max
+    end
+
+    if infos.count == 0
+      # If there were no matches, return 0
+      info = nil
+    elsif infos.count == 1
+      # If there was 1 match, return it
+      info = infos[0]
+    else
+      # Create normalized object
+      info = {
+          zip: "#{zip_min.to_zip}-#{zip_max.to_zip}",
+          city: city,
+          state: state,
+          lat: (lat_min+lat_max)/2,
+          long: (long_min+long_max)/2
+      }
+    end
+
+    # Cache the value
+    self.city_cache[cache_key] = info if info != nil
+
+    # Filter the args
+    self._filter_hash_args info, kwargs[:keys]
+  end
+
+  # Filters arguments in return hash
+  def self._filter_hash_args(hash, keys)
+    return nil if hash == nil
 
-    city_lookup = File.join(this_dir, 'data', 'city_lookup.yml')
-    @@city_lookup = YAML.load(File.open(city_lookup))
+    if keys != nil
+      new_hash = {}
+      keys.each { |k| new_hash[k] = hash[k] }
+      hash = new_hash
+    end
+    hash
   end
 
 end

data/spec/zipcoder_spec.rb

@@ -1,14 +1,116 @@
 require "spec_helper"
 
 describe Zipcoder do
-  before(:all) {
+  before(:all) do
     described_class.load_data
-  }
+  end
+
+  before(:each) do
+    described_class.city_cache.clear
+  end
 
   it "has a version number" do
     expect(Zipcoder::VERSION).not_to be nil
   end
 
+  describe "#zip_info" do
+    it "returns the info for a particular zip_code" do
+      zip_info = described_class.zip_info "78748"
+      expect(zip_info[:city]).to eq("AUSTIN")
+      expect(zip_info[:state]).to eq("TX")
+      expect(zip_info[:zip]).to eq("78748")
+      expect(zip_info[:lat]).to eq(30.26)
+      expect(zip_info[:long]).to eq(-97.74)
+    end
+
+    it "returns the info for a particular zip_code" do
+      zip_info = described_class.zip_info 78748
+      expect(zip_info[:city]).to eq("AUSTIN")
+      expect(zip_info[:state]).to eq("TX")
+      expect(zip_info[:zip]).to eq("78748")
+      expect(zip_info[:lat]).to eq(30.26)
+      expect(zip_info[:long]).to eq(-97.74)
+    end
+
+    it "zero pads the zip code when using an integer" do
+      zip_info = described_class.zip_info 705
+      expect(zip_info[:city]).to eq("AIBONITO")
+    end
+
+    describe "keys filter" do
+      it "only returns specified keys" do
+        zip_info = described_class.zip_info "78748", keys: [:city, :state]
+        expect(zip_info[:city]).to eq("AUSTIN")
+        expect(zip_info[:state]).to eq("TX")
+        expect(zip_info[:zip]).to be_nil
+        expect(zip_info[:lat]).to be_nil
+        expect(zip_info[:long]).to be_nil
+      end
+    end
+
+    describe "city/state filter" do
+      it "returns zip codes that match a particular city" do
+        zip_infos = described_class.zip_info city: "Austin"
+        expect(zip_infos.count).to eq(54)
+      end
+
+      it "returns zip codes that match a particular state" do
+        zip_infos = described_class.zip_info state: "TX"
+        expect(zip_infos.count).to eq(1745)
+      end
+
+      it "returns zip codes that match a particular city/state" do
+        zip_infos = described_class.zip_info city: "Austin", state: "TX"
+        expect(zip_infos.count).to eq(47)
+      end
+    end
+
+  end
+
+  describe "#city_info" do
+    it "raises exception if no ','" do
+      expect {
+        described_class.city_info "Austin TX"
+      }.to raise_error(Exception)
+    end
+
+    it "returns the normalized city/state value" do
+      city_info = described_class.city_info "Austin, TX"
+      expect(city_info[:city]).to eq("AUSTIN")
+      expect(city_info[:state]).to eq("TX")
+      expect(city_info[:zip]).to eq("78701-78799")
+      expect(city_info[:lat]).to eq(30.315)
+      expect(city_info[:long]).to eq(-48.87)
+    end
+
+    it "returns the normalized city/state filtered" do
+      city_info = described_class.city_info "Austin, TX", keys: [:zip, :lat, :long]
+      expect(city_info[:city]).to be_nil
+      expect(city_info[:state]).to be_nil
+      expect(city_info[:zip]).to eq("78701-78799")
+      expect(city_info[:lat]).to eq(30.315)
+      expect(city_info[:long]).to eq(-48.87)
+    end
+
+    it "caches the unfiltered value" do
+      expect {
+        described_class.city_info "Austin, TX", keys: [:zip, :lat, :long]
+      }.to change{ described_class.city_cache.values.count }.by(1)
+
+      expect {
+        described_class.city_info "Austin, TX"
+      }.to change{ described_class.city_cache.values.count }.by(0)
+
+      city_info = described_class.city_info "Austin, TX"
+      expect(city_info[:city]).to eq("AUSTIN")
+      expect(city_info[:state]).to eq("TX")
+      expect(city_info[:zip]).to eq("78701-78799")
+      expect(city_info[:lat]).to eq(30.315)
+      expect(city_info[:long]).to eq(-48.87)
+    end
+  end
+
+
   describe("String") do
     describe "zip lookup" do
       it "returns the info for a particular zip_code" do
@@ -21,7 +123,7 @@ describe Zipcoder do
       end
 
       it "only returns specified keys" do
-        zip_info = "78748".zip_info(keys: [:city, :state])
+        zip_info = "78748".zip_info keys: [:city, :state]
         expect(zip_info[:city]).to eq("AUSTIN")
         expect(zip_info[:state]).to eq("TX")
         expect(zip_info[:zip]).to be_nil
@@ -35,17 +137,17 @@ describe Zipcoder do
         city_info = "Austin, TX".city_info
         expect(city_info[:city]).to eq("AUSTIN")
         expect(city_info[:state]).to eq("TX")
-        expect(city_info[:zips].count).to eq(81)
-        expect(city_info[:lats].count).to eq(81)
-        expect(city_info[:longs].count).to eq(81)
+        expect(city_info[:zip]).to eq("78701-78799")
+        expect(city_info[:lat]).to eq(30.315)
+        expect(city_info[:long]).to eq(-48.87)
       end
       it "only returns specified keys" do
-        city_info = "Austin, TX".city_info(keys: [:zips, :city])
+        city_info = "Austin, TX".city_info keys: [:zip, :city]
         expect(city_info[:city]).to eq("AUSTIN")
         expect(city_info[:state]).to be_nil
-        expect(city_info[:zips].count).to eq(81)
-        expect(city_info[:lats]).to be_nil
-        expect(city_info[:longs]).to be_nil
+        expect(city_info[:zip]).to eq("78701-78799")
+        expect(city_info[:lat]).to be_nil
+        expect(city_info[:long]).to be_nil
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zipcoder
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric Chapman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-10 00:00:00.000000000 Z
+date: 2018-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,8 +99,7 @@ files:
 - bin/console
 - bin/setup
 - circle.yml
-- lib/data/city_lookup.yml
-- lib/data/zip_lookup.yml
+- lib/data/zip_data.yml
 - lib/data/zipcode.csv
 - lib/ext/integer.rb
 - lib/ext/string.rb