rate_center 0.1.2

data/lib/rate_center/city.rb

@@ -0,0 +1,33 @@
+
+require "ostruct"
+require_relative "collection"
+require_relative "vector"
+require_relative "distance"
+
+module RateCenter
+  class City < OpenStruct
+    extend Collection
+
+    class << self
+      private
+
+      def data
+        ::RateCenter.data_loader.cities
+      end
+
+      def load_collection
+        data.map do |data|
+          city = new(**data)
+          city.nearby_rate_centers = Array(data["nearby_rate_centers"]).map do |rate_center|
+            distance = rate_center.fetch("distance")
+            Vector.new(
+              name: rate_center.fetch("name"),
+              distance: Distance.new(value: distance.fetch("value"), units: distance.fetch("units"))
+            )
+          end
+          city
+        end
+      end
+    end
+  end
+end

data/lib/rate_center/collection.rb

@@ -0,0 +1,23 @@
+module RateCenter
+  module Collection
+    def collection
+      raise Errors::DataNotLoadedError.new("No data loaded. Load data with RateCenter.load before calling this method") if data.nil?
+
+      @collection ||= load_collection
+    end
+
+    def all
+      collection
+    end
+
+    def find_by(attributes)
+      collection.find do |region|
+        attributes.all? { |key, value| region[key] == value }
+      end
+    end
+
+    def find_by!(*)
+      find_by(*) || raise(Errors::NotFoundError.new)
+    end
+  end
+end

data/lib/rate_center/data_loader.rb

@@ -0,0 +1,75 @@
+require "yaml"
+
+module RateCenter
+  class DataLoader
+    attr_reader :data_directory, :cities, :rate_centers
+
+    def initialize(**options)
+      @data_directory = options.fetch(:data_directory) { Pathname(File.expand_path("../../data/", __dir__)) }
+    end
+
+    def load(type, ...)
+      case type.to_sym
+      when :all
+        @cities = load_data("cities", :all)
+        @rate_centers = load_data("rate_centers", :all)
+      when :cities
+        @cities = load_data("cities", ...)
+      when :rate_centers
+        @rate_centers = load_data("rate_centers", ...)
+      else
+        raise ArgumentError, "Invalid type: #{type}"
+      end
+
+      nil
+    end
+
+    private
+
+    def load_data(type, all = nil, **options)
+      if all
+        load_data_from(data_directory.join(type).glob("**/*.yml"), type:)
+      else
+        load_data_with_filter(options.fetch(:only), type:)
+      end
+    end
+
+    def load_data_with_filter(filter, type:)
+      unless filter.is_a?(Hash)
+        return Array(filter).each_with_object([]) do |country, result|
+          result.concat(load_country_data(type:, country:))
+        end
+      end
+
+      filter.each_with_object([]) do |(country, regions), result|
+        if regions.is_a?(Hash)
+          regions.each do |region, keys|
+            data = load_region_data(type:, country:, region:)
+            result.concat(data.select { |d| Array(keys).include?(d.fetch("name")) })
+          end
+        else
+          Array(regions).each do |region|
+            result.concat(load_region_data(type:, country:, region:))
+          end
+        end
+      end
+    end
+
+    def load_data_from(files, type:)
+      Array(files).each_with_object([]) do |file, result|
+        result.concat(YAML.load(file.read).fetch(type))
+      end
+    end
+
+    def load_country_data(type:, country:)
+      load_data_from(data_directory.join(type.to_s, country.to_s.downcase).glob("**/*.yml"), type:)
+    end
+
+    def load_region_data(type:, country:, region:)
+      load_data_from(
+        data_directory.join(type.to_s, country.to_s.downcase, "#{region.to_s.downcase}.yml"),
+        type:
+      )
+    end
+  end
+end

data/lib/rate_center/data_prep.rb

@@ -0,0 +1,121 @@
+require "yaml"
+require "geocoder"
+
+module RateCenter
+  class DataPrep
+    attr_reader :data_directory, :logger
+
+    def initialize(**options)
+      @data_directory = options.fetch(:data_directory)
+    end
+
+    def call
+      update_rate_centers_with_closest_city
+      update_cities_with_nearby_rate_centers
+    end
+
+    private
+
+    def update_rate_centers_with_closest_city
+      rate_center_data.each do |region, rate_centers|
+        rate_centers.each do |rate_center|
+          next if rate_center["lat"].nil? || rate_center["long"].nil?
+
+          closest_city = find_closest(
+            lat: rate_center.fetch("lat"),
+            long: rate_center.fetch("long"),
+            data: city_data[region],
+            key: ->(data) { data.fetch("name") }
+          ).first
+
+          next if closest_city.nil?
+
+          rate_center["closest_city"] = {
+            "name" => closest_city.name,
+            "distance" => {
+              "value" => closest_city.distance.round(2),
+              "units" => "km"
+            }
+          }
+        end
+      end
+
+      write_data("rate_centers", "us", rate_center_data)
+    end
+
+    def update_cities_with_nearby_rate_centers
+      city_data.each do |region, cities|
+        candidates = Array(rate_center_data[region]).reject { |data| data["lat"].nil? }
+
+        cities.each do |city|
+          candidate_distances = find_closest(
+            lat: city.fetch("lat"),
+            long: city.fetch("long"),
+            data: candidates,
+            key: ->(data) { data.fetch("name") }
+          )
+
+          candidates_by_distance = candidate_distances.each_with_object(Hash.new { |h, k| h[k] = [] }) do |rate_center, result|
+            result[rate_center.distance] << rate_center
+          end
+
+          nearby_rate_centers = candidates_by_distance.keys.first(3).each_with_object([]) do |distance, result|
+            result.concat(candidates_by_distance.fetch(distance))
+          end
+
+          city["nearby_rate_centers"] = nearby_rate_centers.map do |rate_center|
+            {
+              "name" => rate_center.name,
+              "distance" => {
+                "value" => rate_center.distance.round(2),
+                "units" => "km"
+              }
+            }
+          end
+        end
+      end
+
+      write_data("cities", "us", city_data)
+    end
+
+    def find_closest(lat:, long:, data:, key:)
+      distance_to = Class.new(Struct.new(:name, :distance, keyword_init: true))
+
+      distances_to = Array(data).map do |d|
+        distance_to.new(
+          name: key.call(d),
+          distance: Geocoder::Calculations.distance_between(
+            [ lat, long ],
+            [ d.fetch("lat"), d.fetch("long") ],
+            units: :km
+          )
+        )
+      end
+
+      distances_to.sort_by(&:distance)
+    end
+
+    def write_data(type, country, data)
+      data.each do |state, state_data|
+        state_file = data_directory.join(type, country, "#{state.downcase}.yml")
+        state_file.write({ type => state_data }.to_yaml)
+      end
+    end
+
+    def city_data
+      @city_data ||= load_data("cities", "us")
+    end
+
+    def rate_center_data
+      @rate_center_data ||= load_data("rate_centers", "us")
+    end
+
+    def load_data(type, country)
+      data_directory.join(type, country).glob("**/*.yml").each_with_object({}) do |state_file, result|
+        data = YAML.load(state_file.read)
+        state = state_file.basename(".yml").to_s
+        result[state.upcase] = data.fetch(type.to_s)
+      end
+    end
+  end
+end

data/lib/rate_center/data_source/local_calling_guide.rb

@@ -0,0 +1,107 @@
+require "faraday"
+require "multi_xml"
+require "rack"
+require "yaml"
+require "countries"
+require "ostruct"
+
+module RateCenter
+  module DataSource
+    class LocalCallingGuide
+      attr_reader :client, :data_directory
+
+      def initialize(**options)
+        @client = options.fetch(:client) { Client.new }
+      end
+
+      class ResponseParser
+        Response = Struct.new(:rate_centers, keyword_init: true)
+
+        attr_reader :parser
+
+        def initialize(**options)
+          @parser = options.fetch(:parser) { MultiXml }
+        end
+
+        def parse(xml)
+          data = parser.parse(xml)
+          rc_data = data.dig("root", "rcdata")
+
+          return Response.new(rate_centers: []) if rc_data.nil?
+
+          rc_data = rc_data.is_a?(Array) ? rc_data : Array([ rc_data ])
+          rate_centers = rc_data.map do |d|
+            OpenStruct.new(d.transform_values { |v| v.strip unless v.strip.empty? })
+          end
+
+          Response.new(rate_centers: rate_centers)
+        end
+      end
+
+      class Client
+        HOST = "https://localcallingguide.com/".freeze
+
+        attr_reader :host, :http_client, :response_parser
+
+        def initialize(**options)
+          @host = options.fetch(:host, HOST)
+          @http_client = options.fetch(:http_client) { default_http_client }
+          @response_parser =  options.fetch(:response_parser) { ResponseParser.new }
+        end
+
+        def fetch_rate_center_data(params)
+          uri = URI("/xmlrc.php")
+          uri.query = Rack::Utils.build_query(params)
+          response = http_client.get(uri)
+          response_parser.parse(response.body)
+        end
+
+        private
+
+        def default_http_client
+          Faraday.new(url: host) do |builder|
+            builder.headers["Accept"] = "application/xml"
+            builder.headers["Content-Type"] = "application/xml"
+
+            builder.response :raise_error
+          end
+        end
+      end
+
+      def load_data!(**options)
+        data_directory = options.fetch(:data_directory)
+        FileUtils.mkdir_p(data_directory)
+
+        us_regions = Array(regions_for("US"))
+
+        Array(us_regions).each do |region, _|
+          data_file = data_directory.join("#{region.downcase}.yml")
+          rate_centers = client.fetch_rate_center_data(region:).rate_centers
+          next if rate_centers.empty?
+
+          data = rate_centers.sort_by(&:rc).map do |rate_center|
+            {
+              "country" => "US",
+              "region" => region,
+              "exchange" => rate_center.exch,
+              "name" => rate_center.rcshort || rate_center.rc,
+              "full_name" => rate_center.rc,
+              "lata" => rate_center.lata,
+              "ilec_name" => rate_center.ilec_name,
+              "lat" => rate_center.rc_lat,
+              "long" => rate_center.rc_lon
+            }
+          end
+
+          data_file.write({ "rate_centers" => data }.to_yaml)
+        end
+      end
+
+      private
+
+      def regions_for(country_code)
+        ISO3166::Country.new(country_code).subdivisions
+      end
+    end
+  end
+end

data/lib/rate_center/data_source/simple_maps.rb

@@ -0,0 +1,93 @@
+require "faraday"
+require "zip"
+require "csv"
+require "yaml"
+require "ostruct"
+
+module RateCenter
+  module DataSource
+    class SimpleMaps
+      class ResponseParser
+        DATABASE_FILENAME = "uscities.csv".freeze
+
+        def parse(response)
+          database_file = extract_zipped_file(response, filename: DATABASE_FILENAME)
+
+          CSV.parse(database_file.read, headers: true).each_with_object([]) do |row_data, result|
+            result << OpenStruct.new(row_data.to_h)
+          end
+        end
+
+        private
+
+        def extract_zipped_file(zip_data, filename:)
+          Zip::InputStream.open(StringIO.new(zip_data)) do |zip_stream|
+            while (entry = zip_stream.get_next_entry)
+              return entry.get_input_stream if entry.name == filename
+            end
+          end
+        end
+      end
+
+      class Client
+        HOST = "https://simplemaps.com/".freeze
+        DEFAULT_DOWNLOAD_PATH = "static/data/us-cities/1.79/basic/simplemaps_uscities_basicv1.79.zip"
+
+        attr_reader :host, :http_client, :response_parser
+
+        def initialize(**options)
+          @host = options.fetch(:host, HOST)
+          @http_client = options.fetch(:http_client) { default_http_client }
+          @response_parser =  options.fetch(:response_parser) { ResponseParser.new }
+        end
+
+        def fetch_data(**options)
+          uri = URI(options.fetch(:path, DEFAULT_DOWNLOAD_PATH))
+          response = http_client.get(uri)
+          response_parser.parse(response.body)
+        end
+
+        private
+
+        def default_http_client
+          Faraday.new(url: host) do |builder|
+            builder.response :raise_error
+          end
+        end
+      end
+
+      attr_reader :client, :data_directory
+
+      def initialize(**options)
+        @client = options.fetch(:client) { Client.new }
+      end
+
+      def load_data!(**options)
+        data_directory = options.fetch(:data_directory)
+        FileUtils.mkdir_p(data_directory)
+
+        data = client.fetch_data
+
+        cities_by_state = data.each_with_object(Hash.new { |h, k| h[k] = [] }) do |city, result|
+          result[city.state_id] << city
+        end
+
+        cities_by_state.each do |state, cities|
+          data_file = data_directory.join("#{state.downcase}.yml")
+
+          data = cities.sort_by(&:city).map do |city|
+            {
+              "country" => "US",
+              "region" => city.state_id,
+              "name" => city.city,
+              "lat" => city.lat,
+              "long" => city.lng
+            }
+          end
+
+          data_file.write({ "cities" => data }.to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/rate_center/distance.rb

@@ -0,0 +1,3 @@
+module RateCenter
+  Distance = Struct.new(:value, :units, keyword_init: true)
+end

data/lib/rate_center/errors.rb

@@ -0,0 +1,6 @@
+module RateCenter
+  module Errors
+    class NotFoundError < StandardError; end
+    class DataNotLoadedError < StandardError; end
+  end
+end

data/lib/rate_center/rate_center.rb

@@ -0,0 +1,34 @@
+require "ostruct"
+require_relative "collection"
+require_relative "vector"
+require_relative "distance"
+
+module RateCenter
+  class RateCenter < OpenStruct
+    extend Collection
+
+    class << self
+      private
+
+      def data
+        ::RateCenter.data_loader.rate_centers
+      end
+
+      def load_collection
+        data.map do |data|
+          rate_center = new(**data)
+          closest_city = data["closest_city"]
+          next rate_center if closest_city.nil?
+
+          distance = closest_city.fetch("distance")
+          rate_center.closest_city = Vector.new(
+            name: closest_city.fetch("name"),
+            distance: Distance.new(value: distance.fetch("value"), units: distance.fetch("units"))
+          )
+
+          rate_center
+        end
+      end
+    end
+  end
+end

data/lib/rate_center/vector.rb

@@ -0,0 +1,3 @@
+module RateCenter
+  Vector = Struct.new(:name, :distance, keyword_init: true)
+end

data/lib/rate_center/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RateCenter
+  VERSION = "0.1.2"
+end

data/lib/rate_center.rb

@@ -0,0 +1,21 @@
+module RateCenter
+  class << self
+    def load(...)
+      data_loader.load(...)
+    end
+
+    def unload
+      @data_loader = nil
+    end
+
+    def data_loader
+      @data_loader ||= DataLoader.new
+    end
+  end
+end
+
+require_relative "rate_center/errors"
+require_relative "rate_center/data_loader"
+require_relative "rate_center/city"
+require_relative "rate_center/rate_center"
+require_relative "rate_center/version"

data/release-please-config.json

@@ -0,0 +1,15 @@
+{
+  "include-component-in-tag": false,
+  "version-file": "lib/rate_center/version.rb",
+  "packages": {
+    ".": {
+      "changelog-path": "CHANGELOG.md",
+      "release-type": "ruby",
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": false,
+      "draft": false,
+      "prerelease": false
+    }
+  },
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
+}