ip_api_service 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 508fddf5e55811a7f08ae47583e4627631d925c6d6a1e91c3536bd457b3856e4
+  data.tar.gz: 7d302d15e4d3e6e5334d8fafccd9cbb9c4428babe520f9b17c3aa5679e1b277f
+SHA512:
+  metadata.gz: 60516003088fa1217aa0e8fce5d106744efeecb1a2569ccc1d8076ddc746309a1652ed78d8e578a8755dc74b8a500e74308100196f3c10cec4ea7b629fc70eb7
+  data.tar.gz: 0a2390cfe4396ca468630c8f4fc1bb520612c9fdc8321197881991443c7764ff46929efb06789c5a9c42226a03ce5c5aa8893a605a037c5f411f411db640bd72

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  Exclude:
+    - "**/vendor/**/*"
+    - "**/*.gemspec"
+    - "spec/**"
+  NewCops: enable
+  TargetRubyVersion: 3.0.1
+  SuggestExtensions: false
+
+Style/Documentation:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Style/AsciiComments:
+  Enabled: false
+
+# NOTE: for rspec tests
+Metrics/BlockLength:
+  IgnoredMethods: ['describe', 'context']

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ip_api_service.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+gem 'nokogiri-happymapper'
+
+gem 'addressable'
+
+group :develop do
+  gem 'minitest', '~> 5.0'
+  gem 'minitest-power_assert'
+  gem 'webmock'
+end

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    ip_api_service (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    crack (0.4.5)
+      rexml
+    hashdiff (1.0.1)
+    minitest (5.15.0)
+    minitest-power_assert (0.3.1)
+      minitest
+      power_assert (>= 1.1)
+    nokogiri (1.13.3-x86_64-linux)
+      racc (~> 1.4)
+    nokogiri-happymapper (0.9.0)
+      nokogiri (~> 1.5)
+    power_assert (2.0.1)
+    public_suffix (4.0.6)
+    racc (1.6.0)
+    rake (13.0.6)
+    rexml (3.2.5)
+    webmock (3.14.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  addressable
+  ip_api_service!
+  minitest (~> 5.0)
+  minitest-power_assert
+  nokogiri-happymapper
+  rake (~> 13.0)
+  webmock
+
+BUNDLED WITH
+   2.3.7

data/Makefile

@@ -0,0 +1,8 @@
+test:
+	test -s solution
+install:
+	bundle install
+tdd:
+	rake test
+
+.PHONY: test

data/README.md

@@ -0,0 +1,79 @@
+# IpApiService
+
+![logo](https://ip-api.com/docs/static/logo.png)
+
+Ruby клинет для сервиса [ip-api.com](https://ip-api.com/). Сервис позволяет получать данные геолокации по ip адресу.
+
+## Установка
+
+```ruby
+gem 'ip-api-service'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ip-api-service
+
+## Использование
+
+Вы можете получить данные геолокации ip адреса вызвав метод IpApiService.lookup и передав ему следующие параметры:
+
+* ip - ip адрес
+* fields - массив с нужными полями 
+* result_format - формат желаемого результата
+* lang - язык
+
+Результатом метода, при вызове с параметром result_format: :ipMetaInfo, будет объект.
+Значения запрашиваемх полей будут доступны по геттеру с именем поля
+
+```ruby
+info = IpApiService.lookup '8.8.8.8'
+puts info.city
+```
+Во всех других случаях результатом метода будет строка
+
+Доступные для запроса поля можно получить вызвав метод available_fields
+
+```ruby
+IpApiService.available_fields
+```
+
+Поддерживаемые форматы результата - available_formats
+
+```ruby
+IpApiService.available_formats
+```
+
+Доступные языки - available_languages
+
+```ruby
+IpApiService.available_languages
+```
+
+Используя метод field_description(field) vожно получить описание поля
+
+```ruby
+IpApiServiceIpApiService.field_description :region
+```
+
+Параметр ip для метода lookup обязательный, остальные можно установить по умолчанию 
+
+```ruby
+IpApiService.default_fields = %i(city country countryCode lat lon)
+IpApiService.result_format = :json
+IpApiService.default_language = :en
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mike090/ip_api_service.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/ip_api_service.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/ip_api_service/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ip_api_service"
+  spec.version = IpApiService::VERSION
+  spec.authors = ["mike09"]
+  spec.email = ["mike09@mail.ru"]
+
+  spec.summary = "API for ip-api.com"
+  spec.homepage = "https://github.com/mike090/ip_api_service"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/mike090/ip_api_service"
+  spec.metadata["changelog_uri"] = "https://github.com/mike090/ip_api_service"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/ip_api_service/ip_api_adapter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../web_service/uri_mapper'
+require_relative '../web_service/http_command'
+require_relative 'ip_api_response_processor'
+
+module IpApiService
+  # available meta fields
+  META_FIELDS = {
+    continent: { type: :string, description: 'Continent name' },
+    continentCode: { type: :string, description: 'Two-letter continent code' },
+    country: { type: :string, description: 'Country name' },
+    countryCode: { type: :string, description: 'Two-letter country code ISO 3166-1 alpha-2' },
+    region: { type: :string, description: 'Region/state short code (FIPS or ISO)' },
+    regionName: { type: :string, description: 'Region/state' },
+    city: { type: :string, description: 'City' },
+    district: { type: :string, description: 'District (subdivision of city)' },
+    zip: { type: :string,  description: 'Zip code' },
+    lat: { type: :float,   description: 'Latitude' },
+    lon: { type: :float,   description: 'Longitude' },
+    timezone: { type: :string, description: 'Timezone (tz)' },
+    offset: { type: :integer, description: 'Timezone UTC DST offset in seconds' },
+    currency: { type: :string, description: 'National currency' },
+    isp: { type: :string,  description: 'ISP name' },
+    org: { type: :string,  description: 'Organization name' },
+    as: { type: :string,
+          description: "AS number and organization, separated by space (RIR). Empty for IP blocks \
+          'not being announced in BGP tables." },
+    asname: { type: :string,
+              description: 'AS name (RIR). Empty for IP blocks not being announced in BGP tables' },
+    reverse: { type: :string, description: 'Reverse DNS of the IP (can delay response)' },
+    mobile: { type: :boolean, description: 'Mobile (cellular) connection' },
+    proxy: { type: :boolean, description: 'Proxy, VPN or Tor exit address' },
+    hosting: { type: :boolean, description: 'Hosting, colocated or data center' }
+  }.freeze
+  private_constant :META_FIELDS
+
+  # service fields
+  SERVICE_FIELDS = {
+    status: :string,
+    message: :string,
+    query: :string
+  }.freeze
+  private_constant :SERVICE_FIELDS
+
+  FIELD_TYPES = META_FIELDS.transform_values do |field_scheme|
+    field_scheme[:type]
+  end.merge(SERVICE_FIELDS).freeze
+  private_constant :FIELD_TYPES
+
+  IP_API_COMMAND_TEMPLATE = 'http://ip-api.com/{format}/{ip}{?fields}{&lang}'
+  private_constant :IP_API_COMMAND_TEMPLATE
+
+  USER_AGENT = 'IpApiService/Ruby/1.0'
+  private_constant :USER_AGENT
+
+  ACCEPT_MIME_TYPES = {
+    json: 'application/json',
+    xml: 'application/xml',
+    csv: 'text/csv',
+    newline: 'text/plain',
+    php: 'text/php'
+  }.freeze
+  private_constant :ACCEPT_MIME_TYPES
+
+  class IpApiAdapter
+    def initialize
+      mapper = WebService::UriMapper
+      @command = WebService::HttpCommand.new mapper
+    end
+
+    def ip_meta_info(ip, fields, result_format, lang)
+      target_fields = SERVICE_FIELDS.keys + fields
+      target_format = result_format == :ipMetaInfo ? :xml : result_format
+      headers = prepare_headers target_format
+      response = @command.execute :get, IP_API_COMMAND_TEMPLATE, ip: ip, format: target_format, fields: target_fields,
+                                                                 lang: lang, headers: headers
+      return response_processor.process_response(response, target_format, fields) if result_format == :ipMetaInfo
+
+      response.body
+    end
+
+    private
+
+    def response_processor
+      @response_processor ||= ResponseProcessor.new
+    end
+
+    def prepare_headers(format)
+      {
+        'User-Agent' => USER_AGENT,
+        'Accept' => ACCEPT_MIME_TYPES[format],
+        'Accept-Encoding' => 'utf-8'
+      }
+    end
+  end
+end

data/lib/ip_api_service/ip_api_response_processor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../web_service/http_response_processor'
+require_relative 'serialization'
+
+module IpApiService
+  XML_RESPONSE_ROOT = 'query'
+  private_constant :XML_RESPONSE_ROOT
+
+  IP_API_SUCCESS_STATUS = 'success'
+  private_constant :IP_API_SUCCESS_STATUS
+
+  class ResponseProcessorError < StandardError; end
+
+  class ServiceError < StandardError
+    attr_reader :query, :service_message
+
+    def initialize(query, service_message)
+      @query = query
+      @service_message = service_message
+      super 'Service return fail result'
+    end
+  end
+
+  class ResponseProcessor < WebService::HttpResponseProcessor
+    def process_response(response, content_type, fields)
+      super response
+      ip_api_result = service_parser(content_type).parse response.body
+      unless ip_api_result.status == IP_API_SUCCESS_STATUS
+        raise ServiceError.new(ip_api_result.query,
+                               ip_api_result.message)
+      end
+
+      parser(content_type, fields).parse response.body
+    end
+
+    private
+
+    def parser(content_type, fields)
+      case content_type
+      when :xml
+        fields = FIELD_TYPES.slice(*fields) unless fields.is_a? Hash
+        Serialization.xml_parser XML_RESPONSE_ROOT, fields
+      when :json
+        Serialization.json_parser fields
+      else
+        raise ResponseProcessorError 'Parser not implemented'
+      end
+    end
+
+    def service_parser(content_type)
+      case content_type
+      when :xml
+        @xml_service_parser || parser(:xml, SERVICE_FIELDS)
+      when :json
+        @json_service_parser || parser(:json, SERVICE_FIELDS)
+      end
+    end
+  end
+end

data/lib/ip_api_service/serialization.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'happymapper'
+
+module IpApiService
+  module Serialization
+    module_function
+
+    class UnknownTypeError < StandardError; end
+
+    # подскажи, как обозвать
+    @type_tra_ta_ta = {
+      string: String,
+      integer: Integer,
+      float: Float,
+      time: Time,
+      date: Date,
+      datetime: DateTime,
+      boolean: HappyMapper::Boolean
+    }
+
+    class JsonParser
+      def initialize(fields)
+        fields = fields.keys if fields.is_a? Hash
+        @fields = fields
+      end
+
+      def parse(json_content)
+        raw = JSON.parse(json_content).transform_keys(&:to_sym).slice(*@fields)
+        Struct.new(*raw.keys).new(*raw.values_at(*raw.keys))
+      end
+    end
+
+    def json_parser(fields)
+      JsonParser.new fields
+    end
+
+    def xml_parser(root, fields)
+      parser = Class.new.include HappyMapper
+      parser.tag root
+      fields.each do |field, field_type|
+        begin
+          field_type = @type_tra_ta_ta.fetch field_type
+        rescue KeyError
+          raise UnknownTypeError "Unknown field type :#{field_type}"
+        end
+        parser.element field, field_type
+      end
+      parser
+    end
+  end
+end

data/lib/ip_api_service/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module IpApiService
+  VERSION = '0.1.0'
+end

data/lib/ip_api_service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative './ip_api_service/ip_api_adapter'
+require 'resolv'
+
+module IpApiService
+  extend self
+
+  AVAILABLE_LANGUAGES = %i[en de es pt-BR fr ja zh-CN ru].freeze
+
+  AVAILABLE_FORMATS = %i[ipMetaInfo json xml csv line php].freeze
+
+  DEFAULT_FIELDS = %i[country countryCode region regionName city zip lat lon timezone isp org as].freeze
+  private_constant :AVAILABLE_LANGUAGES, :AVAILABLE_FORMATS, :DEFAULT_FIELDS
+
+  @default_language = :en
+  @custom_default_fields = DEFAULT_FIELDS
+  @result_format = :ipMetaInfo
+
+  attr_reader :available_langviges, :available_formats, :default_language, :result_format
+
+  def available_fields
+    META_FIELDS.keys
+  end
+
+  def available_languages
+    AVAILABLE_LANGUAGES
+  end
+
+  def default_language=(value)
+    @default_language = AVAILABLE_LANGUAGES.include?(value) ? value : :en
+  end
+
+  def result_format=(value)
+    @result_format = AVAILABLE_FORMATS.include?(value) ? value : metaInfo
+  end
+
+  def field_description(field)
+    META_FIELDS[field][:description]
+  end
+
+  def default_fields=(value)
+    value &= META_FIELDS.keys
+    @custom_default_fields = value.empty? ? @default_fields : value
+  end
+
+  def default_fields
+    @custom_default_fields
+  end
+
+  def lookup(ip, fields: default_fields, result_format: @result_format, lang: @default_language)
+    raise ArgumentError, 'Unavailable result_format' unless AVAILABLE_FORMATS.include? result_format
+    raise ArgumentError, 'Unavailable language' unless AVAILABLE_LANGUAGES.include? lang
+
+    resolv = ip =~ Resolv::IPv4::Regex ? true : (ip =~ Resolv::IPv6::Regex)
+    raise ArgumentError, 'Invalid ip addess' unless resolv
+
+    fields = default_fields if fields.empty?
+    adapter.ip_meta_info ip, fields, result_format, lang
+  end
+
+  private
+
+  def adapter
+    @adapter ||= IpApiAdapter.new
+  end
+end

data/lib/web_service/http_command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module WebService
+  class HttpUnknownMethodError < StandardError; end
+  class ConnectionError < StandardError; end
+
+  HTTP_COMMAND_METHODS = {
+    get: Net::HTTP::Get,
+    post: Net::HTTP::Post,
+    head: Net::HTTP::Head,
+    patch: Net::HTTP::Patch,
+    put: Net::HTTP::Put,
+    proppatch: Net::HTTP::Proppatch,
+    lock: Net::HTTP::Lock,
+    unlock: Net::HTTP::Unlock,
+    options: Net::HTTP::Options,
+    propfind: Net::HTTP::Propfind,
+    delete: Net::HTTP::Delete,
+    move: Net::HTTP::Move,
+    copy: Net::HTTP::Copy,
+    mkol: Net::HTTP::Mkcol,
+    trace: Net::HTTP::Trace
+  }.freeze
+  private_constant :HTTP_COMMAND_METHODS
+
+  class HttpCommand
+    def initialize(mapper)
+      @mapper = mapper
+    end
+
+    def execute(command, template, **params) # rubocop:disable Metrics/AbcSize
+      request_class = HTTP_COMMAND_METHODS[command]
+      raise HttpUnknownMethodError, "Unknown Http command: #{command}" unless request_class
+
+      headers = (params.delete :headers) || {}
+      body = params.delete :body
+      body = nil unless request_class::REQUEST_HAS_BODY
+      uri = @mapper.map_template template, **params
+      request = request_class.new uri, {}
+      headers.each { |header, value| request[header] = value }
+      begin
+        Net::HTTP.start(uri.host, uri.port) { |http| http.request request, body }
+      rescue StandardError
+        raise ConnectionError, 'Service unavailable'
+      end
+    end
+  end
+end

data/lib/web_service/http_response_processor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module WebService
+  class HttpServiceError < StandardError
+    attr_reader :status_code, :service_message
+
+    def initialize(status_code, service_message)
+      @status_code = status_code
+      @service_message = service_message
+      super 'Service error'
+    end
+  end
+
+  class HttpResponseProcessor
+    def process_response(response)
+      raise HttpServiceError.new(response.code, response.message) unless response.is_a? Net::HTTPSuccess
+
+      response
+    end
+  end
+end

data/lib/web_service/uri_mapper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'addressable/template'
+
+module WebService
+  module UriMapper
+    module_function
+
+    def map_template(template, **mapping)
+      Addressable::Template.new(template).expand mapping
+    end
+  end
+end

data/sig/ip_api_service.rbs

@@ -0,0 +1,4 @@
+module IpApiService
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: ip_api_service
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mike09
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-04-06 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- mike09@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- Makefile
+- README.md
+- Rakefile
+- ip_api_service.gemspec
+- lib/ip_api_service.rb
+- lib/ip_api_service/ip_api_adapter.rb
+- lib/ip_api_service/ip_api_response_processor.rb
+- lib/ip_api_service/serialization.rb
+- lib/ip_api_service/version.rb
+- lib/web_service/http_command.rb
+- lib/web_service/http_response_processor.rb
+- lib/web_service/uri_mapper.rb
+- sig/ip_api_service.rbs
+homepage: https://github.com/mike090/ip_api_service
+licenses: []
+metadata:
+  homepage_uri: https://github.com/mike090/ip_api_service
+  source_code_uri: https://github.com/mike090/ip_api_service
+  changelog_uri: https://github.com/mike090/ip_api_service
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: API for ip-api.com
+test_files: []