zipcoder 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 553ed39e32f59b79a062775295679d51ac2344e4
-  data.tar.gz: a0a184068d50d7846f20c3a774d19d3518f65222
+  metadata.gz: 6acfa10df7bcb97c1d077f57b44eb8f07db3ff49
+  data.tar.gz: 466550b2bbf85a28a1b67381fb6408c71d3b8fcd
 SHA512:
-  metadata.gz: d9072580bc9aef886a9e2a9301f777df3173ac9b73c05fd71e4afb08af39413002e646eb9731e949e7d648a120d04ec876d733b121e089f28b700623bfe867b9
-  data.tar.gz: 228d4c0374c609c44937bcdd8b2348129c3546d697e3ce5f03316fa3a767013c3328e3ede3f7b3f2e4b7613043c21c8b913c245cab226a7d77faceb11ce098d8
+  metadata.gz: 268af7c1b49cd0528cc2caae8d040ee64127063d5cb292f4a26ed62b76e3f910785f74c77425b05466fd0c0ee9e591d7e66d7e26293288d43ac15e4ce2fd4ca7
+  data.tar.gz: f2ba366f03a0ec93c31d62b17fb8ab09ddd274c0e53be3bf1ee3deba1ceecfbf581818faea8f6bba17c608a11baa8e13211a67efdbfbfc5eba399e8d0da284d8

data/README.md

@@ -7,6 +7,8 @@ Gem for performing zip code lookup operations
 
 ## Revision History
 
+ - v0.5.0:
+   - added Redis backend support
  - v0.4.2:
    - updated paths to fix RAILS require issue
  - v0.4.1:
@@ -64,6 +66,33 @@ This will immediately load the data structures.  Currently it takes roughly 3s
 to create and import all of the data structures.  I will look at ways to
 reduce this later.
 
+#### Redis Support
+
+To use Redis as the cache for zipcoder rather than memory, you must do the
+following
+
+**install the 'redis' Gem (or add to your Gemfile if using Rails):**
+
+```ruby
+gme 'redis'
+```
+
+*Note that this Gem supports Ruby >= 2.0 so I could NOT use the latest Redis
+version.  I had to use v3.3.5 to test.*
+
+**create a redis cacher and pass it to the "load_cache" method:**
+
+```ruby
+require 'zipcoder'
+require 'zipcoder/cacher/redis'
+
+cacher = Zipcoder::Cacher::Redis.new(**args)
+Zipcoder.load_cache(cacher)
+```
+
+Please check the [here](https://github.com/redis/redis-rb) for the different
+options to use when instantiating the "Redis" client.
+
 ### Methods
 
 The library overrides the String (and in some instances Integer) class to 

data/lib/zipcoder/cacher/base.rb

@@ -1,111 +1,109 @@
-module Cacher
-  # The cacher base class places all of the objects in memory.  The
-  # abstraction will later allow us to override for MemCacher and
-  # Redis implementations
-  class Base
-
-    #region Override These
-    def _init_cache(**kwargs)
-      @cache = {}
-    end
+module Zipcoder
+  module Cacher
+    # The cacher base class places all of the objects in memory.  The
+    # abstraction will later allow us to override for MemCacher and
+    # Redis implementations
+    class Base
+      KEY_BASE = "zipcoder"
+      KEY_ZIP = "#{KEY_BASE}:zip"
+      KEY_CITY = "#{KEY_BASE}:city"
+      KEY_STATE = "#{KEY_BASE}:state"
+      KEY_STATES = "#{KEY_BASE}:states"
+
+      #region Override These
+      def _init_cache(**kwargs)
+        # Override ME
+      end
 
-    def _empty_cache
-      @cache.clear
-    end
+      def _empty_cache
+        # Override ME
+      end
 
-    def _write_cache(key, value)
-      @cache[key] = value
-    end
+      def _write_cache(key, value)
+        # Override ME
+      end
 
-    def _read_cache(key)
-      @cache[key]
-    end
+      def _read_cache(key)
+        # Override ME
+      end
 
-    def _iterate_keys(**kwargs, &block)
-      return if block == nil
+      def _iterate_keys(**kwargs, &block)
+        # Override ME
+      end
 
-      start_with = kwargs[:start_with]
+      #endregion
 
-      @cache.keys.each do |key|
-        if start_with == nil or key.start_with?(start_with)
-          block.call(key)
-        end
+      def initialize(**kwargs)
+        self._init_cache **kwargs
       end
-    end
 
-    #endregion
+      def load
+        this_dir = File.expand_path(File.dirname(__FILE__))
 
-    def initialize(**kwargs)
-      self._init_cache **kwargs
-    end
+        # Load zip cache from file
+        zip_data = File.join(this_dir, '..', '..', 'data', 'zip_data.yml')
+        zip_codes = YAML.load(File.open(zip_data))
 
-    def load
-      this_dir = File.expand_path(File.dirname(__FILE__))
+        # Initialize
+        _empty_cache
+        city_states = {}
+        state_lookup = {}
 
-      # Load zip cache from file
-      zip_data = File.join(this_dir, '..', '..', 'data', 'zip_data.yml')
-      zip_codes = YAML.load(File.open(zip_data))
+        # Add the zip codes to the cache
+        zip_codes.each do |zip, info|
+          city = _capitalize_all(info[:city])
+          info[:city] = city
+          state = info[:state]
 
-      # Initialize
-      _empty_cache
-      city_states = {}
-      state_lookup = {}
+          # Iterate through the zip codes and add them to the zip cache
+          _write_cache _zip_cache(zip), info
 
-      # Add the zip codes to the cache
-      zip_codes.each do |zip, info|
-        city = _capitalize_all(info[:city])
-        info[:city] = city
-        state = info[:state]
+          # Create the city lookups
+          city_state = "#{city.upcase},#{state.upcase}"
+          infos = city_states[city_state] || []
+          infos << info
+          city_states[city_state] = infos
+        end
 
-        # Iterate through the zip codes and add them to the zip cache
-        _write_cache _zip_cache(zip), info
+        # Normalize each city and populate the state cache
+        city_states.each do |city_state, infos|
+          city = infos[0][:city]
+          state = infos[0][:state]
 
-        # Create the city lookups
-        city_state = "#{city.upcase},#{state.upcase}"
-        infos = city_states[city_state] || []
-        infos << info
-        city_states[city_state] = infos
-      end
+          # Populate the City Cache
+          normalized = _normalize_city(infos)
+          _write_cache _city_cache(city_state), normalized
 
-      # Normalize each city and populate the state cache
-      city_states.each do |city_state, infos|
-        city = infos[0][:city]
-        state = infos[0][:state]
+          # Populate the State Cache
+          cities = state_lookup[state] || []
+          cities << city
+          state_lookup[state] = cities
+        end
 
-        # Populate the City Cache
-        normalized = _normalize_city(infos)
-        _write_cache _city_cache(city_state), normalized
+        # Set the cities cache
+        state_lookup.each do |state, cities|
+          _write_cache _state_cache(state), cities.sort
+        end
 
-        # Populate the State Cache
-        cities = state_lookup[state] || []
-        cities << city
-        state_lookup[state] = cities
+        # Set the states cache
+        self._write_cache _states, state_lookup.keys.sort
       end
 
-      # Set the cities cache
-      state_lookup.each do |state, cities|
-        _write_cache _state_cache(state), cities.sort
+      def read_zip_cache(zip)
+        _read_cache _zip_cache(zip)
       end
 
-      # Set the states cache
-      self._write_cache _states, state_lookup.keys.sort
-    end
-
-    def read_zip_cache(zip)
-      _read_cache _zip_cache(zip)
-    end
-
-    def read_city_cache(city_state)
-      _read_cache _city_cache(city_state)
-    end
+      def read_city_cache(city_state)
+        _read_cache _city_cache(city_state)
+      end
 
-    def read_state_cache(state)
-      _read_cache _state_cache(state)
-    end
+      def read_state_cache(state)
+        _read_cache _state_cache(state)
+      end
 
-    def read_states
-      _read_cache _states
-    end
+      def read_states
+        _read_cache _states
+      end
 
     def iterate_zips(&block)
       return if block == nil
@@ -123,72 +121,73 @@ module Cacher
       end
     end
 
-    private
+      private
 
-    def _zip_cache(zip)
-      "zipcoder:zip:#{zip}"
-    end
+      def _zip_cache(zip)
+        "#{KEY_ZIP}:#{zip}"
+      end
 
-    def _city_cache(city_state)
-      "zipcoder:city:#{city_state}"
-    end
+      def _city_cache(city_state)
+        "#{KEY_CITY}:#{city_state}"
+      end
 
-    def _state_cache(state)
-      "zipcoder:state:#{state}"
-    end
+      def _state_cache(state)
+        "#{KEY_STATE}:#{state}"
+      end
 
-    def _states
-      "zipcoder:states"
-    end
+      def _states
+        KEY_STATES
+      end
 
-    def _capitalize_all(string)
-      string.split(' ').map {|w| w.capitalize }.join(' ')
-    end
+      def _capitalize_all(string)
+        string.split(' ').map {|w| w.capitalize }.join(' ')
+      end
 
-    # Normalizes the values
-    def _normalize_city(infos)
-      # Values
-      zip_min = 100000
-      zip_max = 0
-      lat_min = 200
-      lat_max = -200
-      long_min = 200
-      long_max = -200
-
-      # Iterate through the info and get min/max of zip/lat/long
-      infos.each 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
-
-      # Create the normalized value
-      if infos.count == 0
-        normalized = nil
-      elsif infos.count == 1
-        normalized = {
-            city: infos[0][:city],
-            state: infos[0][:state],
-            zip: infos[0][:zip],
-            lat: infos[0][:lat],
-            long: infos[0][:long],
-        }
-      else
-        normalized = {
-            city: infos[0][:city],
-            state: infos[0][:state],
-            zip: "#{zip_min.to_zip}-#{zip_max.to_zip}",
-            lat: ((lat_min+lat_max)/2).round(4),
-            long: ((long_min+long_max)/2).round(4)
-        }
-      end
-
-      normalized
-    end
+      # Normalizes the values
+      def _normalize_city(infos)
+        # Values
+        zip_min = 100000
+        zip_max = 0
+        lat_min = 200
+        lat_max = -200
+        long_min = 200
+        long_max = -200
+
+        # Iterate through the info and get min/max of zip/lat/long
+        infos.each 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
 
+        # Create the normalized value
+        if infos.count == 0
+          normalized = nil
+        elsif infos.count == 1
+          normalized = {
+              city: infos[0][:city],
+              state: infos[0][:state],
+              zip: infos[0][:zip],
+              lat: infos[0][:lat],
+              long: infos[0][:long],
+          }
+        else
+          normalized = {
+              city: infos[0][:city],
+              state: infos[0][:state],
+              zip: "#{zip_min.to_zip}-#{zip_max.to_zip}",
+              lat: ((lat_min+lat_max)/2).round(4),
+              long: ((long_min+long_max)/2).round(4)
+          }
+        end
+
+        normalized
+      end
+
+    end
   end
-end
+end

data/lib/zipcoder/cacher/memory.rb

@@ -0,0 +1,35 @@
+require_relative 'base'
+
+module Zipcoder
+  module Cacher
+    class Memory < Base
+      def _init_cache(**kwargs)
+        @cache = {}
+      end
+
+      def _empty_cache
+        @cache.clear
+      end
+
+      def _write_cache(key, value)
+        @cache[key] = value
+      end
+
+      def _read_cache(key)
+        @cache[key]
+      end
+
+      def _iterate_keys(**kwargs, &block)
+        return if block == nil
+
+        start_with = kwargs[:start_with]
+
+        @cache.keys.each do |key|
+          if start_with == nil or key.start_with?(start_with)
+            block.call(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zipcoder/cacher/redis.rb

@@ -0,0 +1,46 @@
+require_relative 'base'
+require 'redis'
+require 'json'
+
+module Zipcoder
+  module Cacher
+    class Redis < Base
+
+      # This is here for stubbing
+      def self._create_redis_client(**kwargs)
+        ::Redis.new(**kwargs)
+      end
+
+      def _init_cache(**kwargs)
+        @redis = self.class._create_redis_client(**kwargs)
+      end
+
+      def _empty_cache
+        keys = @redis.keys("#{KEY_BASE}*")
+        @redis.del(*keys) unless keys.empty?
+      end
+
+      def _write_cache(key, value)
+        return if value == nil
+        @redis.set(key, value.to_json)
+      end
+
+      def _read_cache(key)
+        data = @redis.get(key)
+        data == nil ? nil : JSON.parse(data, :symbolize_names => true)
+      end
+
+      def _iterate_keys(**kwargs, &block)
+        return if block == nil
+
+        start_with = kwargs[:start_with] || KEY_BASE
+
+        # Redis "keys" command will pre-filter the keys for us so no
+        # need for "if" statement
+        @redis.keys("#{start_with}*").each do |key|
+          block.call(key)
+        end
+      end
+    end
+  end
+end

data/lib/zipcoder/version.rb

@@ -1,3 +1,3 @@
 module Zipcoder
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/zipcoder.rb

@@ -1,5 +1,5 @@
 require "zipcoder/version"
-require "zipcoder/cacher/base"
+require "zipcoder/cacher/memory"
 require "zipcoder/ext/string"
 require "zipcoder/ext/integer"
 require "yaml"
@@ -19,7 +19,7 @@ module Zipcoder
 
   # Loads the data into memory
   def self.load_cache(cacher=nil)
-    @@cacher = cacher || Cacher::Base.new
+    @@cacher = cacher || Cacher::Memory.new
     self.cacher.load
   end
 

data/spec/cacher_redis_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "zipcoder/cacher/redis"
+
+
+describe Zipcoder::Cacher::Redis do
+  stub_redis_once = false
+
+  before(:each) do
+    unless stub_redis_once
+      allow(Zipcoder::Cacher::Redis).to receive(:_create_redis_client) do
+        RedisStub.new
+      end
+      Zipcoder.load_cache Zipcoder::Cacher::Redis.new
+    end
+
+    stub_redis_once = true
+  end
+
+  describe "#zip_info" do
+    it "match" do
+      info = "78748".zip_info
+      expect(info[:city]).to eq("Austin")
+    end
+
+    it "matches city" do
+      zips = Zipcoder.zip_info city: "Austin", state: "TX"
+      expect(zips.count).to eq(47)
+    end
+
+    it "no match" do
+      info = "78706".zip_info
+      expect(info).to be_nil
+    end
+  end
+
+  describe "#zip_cities" do
+    it "match" do
+      cities = "78748".zip_cities
+      expect(cities.count).to eq(1)
+      expect(cities[0][:city]).to eq("Austin")
+    end
+
+    it "no match" do
+      cities = "78706".zip_cities
+      expect(cities.count).to eq(0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -9,3 +9,59 @@ end
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 require "zipcoder"
 
+class RedisStub
+
+  def initialize
+    @cache = {}
+  end
+
+  def set(key, value)
+    @cache[key] = value
+  end
+
+  def get(key)
+    @cache[key]
+  end
+
+  def keys(filter=nil)
+    if filter == nil
+      @cache.keys
+    else
+      wildcard_start = false
+      wildcard_end = false
+
+      if filter.start_with? '*'
+        wildcard_start = true
+        filter = filter[1..-1]
+      end
+
+      if filter.end_with? '*'
+        wildcard_end = true
+        filter = filter[0..-2]
+      end
+
+      keys = []
+      @cache.keys.each do |key|
+        if wildcard_start and wildcard_end
+          keys << key if key.include? filter
+        elsif wildcard_start
+          keys << key if key.end_with? filter
+        elsif wildcard_end
+          keys << key if key.start_with? filter
+        elsif filter == key
+          keys << key
+        end
+      end
+
+      keys
+    end
+  end
+
+  def del(*keys)
+    keys.each do |key|
+      @cache.delete(key)
+    end
+  end
+
+end
+

data/spec/zipcoder_spec.rb

@@ -1,7 +1,10 @@
 require "spec_helper"
-require 'benchmark'
 
 describe Zipcoder do
+  before(:all) do
+    Zipcoder.load_cache
+  end
+
   it "has a version number" do
     expect(Zipcoder::VERSION).not_to be nil
   end

data/zipcoder.gemspec

@@ -24,5 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '>= 3.5.0'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'codecov'
+  spec.add_development_dependency 'redis', "~> 3.3.5"
   spec.required_ruby_version = '>= 2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zipcoder
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Eric Chapman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-11 00:00:00.000000000 Z
+date: 2018-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.5
 description: 
 email:
 - eric.chappy@gmail.com
@@ -103,9 +117,12 @@ files:
 - lib/data/zipcode.csv
 - lib/zipcoder.rb
 - lib/zipcoder/cacher/base.rb
+- lib/zipcoder/cacher/memory.rb
+- lib/zipcoder/cacher/redis.rb
 - lib/zipcoder/ext/integer.rb
 - lib/zipcoder/ext/string.rb
 - lib/zipcoder/version.rb
+- spec/cacher_redis_spec.rb
 - spec/spec_helper.rb
 - spec/zipcoder_spec.rb
 - zipcoder.gemspec
@@ -134,5 +151,6 @@ signing_key:
 specification_version: 4
 summary: Converts zip codes to cities, lat/long, and vice-versa
 test_files:
+- spec/cacher_redis_spec.rb
 - spec/spec_helper.rb
 - spec/zipcoder_spec.rb