gdsapi-v2-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90763d8f75b2b2da576237c0ff6122f01ea0879d
+  data.tar.gz: e168a1a22eefe7b25ae71fb10192b3353b067eb1
+SHA512:
+  metadata.gz: 8e0b8a2eaba2d2519eae8c5d64cca73d8ac657040b8708e2cd15d4562fefd9edaa26c6a812a80aaca5a36947086786b51b1beb9d54ee7039a74b600aca0cd85e
+  data.tar.gz: a3cfaff0d88682f5191e28ced0b06c7123b619bc3e4daeff81f90b99f99c4ba27b51460042f3e0dd0440baf275c3ee83a2cc3d9b162c55a62d4cd53b4a6d3a0a

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+credentials.json

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gdsapi-v2-ruby.gemspec
+gemspec

data/README.md

@@ -0,0 +1,125 @@
+# Gdsapi::V2::Ruby
+Driver for API.GDS.BUSFOR v2
+
+# Development usage
+1) Run 
+```bash
+    bin/setup
+```
+2) Fill in fields in credentials.json
+3) Run 
+```bash
+    bin/console
+```
+Now you can use client instance for querying GDS
+
+# How to use Client
+## Create Gdsapi::V2::Client instance
+(NOTE: you can use method #client in bin/console)
+### Using Faraday
+Suppose you want to use Faraday as HTTP Driver. So to instantiate client, you can use Gdsapi::V2::Client#with_faraday_requester method:
+```ruby
+Gdsapi::V2::Client.with_faraday_requester base_url: 'https://example.com', login: 'login', password: 'password', language: 'en'
+=> #<Gdsapi::V2::Client:0x007fe3bf1e8d68 @requester=#<Gdsapi::V2::Requester:0x007fe3bf1e9330 @driver=#<Faraday::Connection:0x007fe3bf1eafc8 @parallel_manager=nil, @headers={"User-Agent"=>"Faraday v0.12.1", "Accept-Language"=>"en", "Authorization"=>"Basic bG9naW46cGFzc3dvcmQ="}, @params={}, @options=#<Faraday::RequestOptions (empty)>, @ssl=#<Faraday::SSLOptions (empty)>, @default_parallel_manager=nil, @builder=#<Faraday::RackBuilder:0x007fe3bf1ea640 @handlers=[Faraday::Request::UrlEncoded, Faraday::Adapter::NetHttp]>, @url_prefix=#<URI::HTTPS https://example.com/>, @proxy=nil>, @login="login", @password="password", @language="en">>
+```
+available arguments are: 
+- :base_url - url param for Faraday(requred)
+- :login & :password - HTTP basic auth factors
+- :language: - language slug for which request will be performed (available are: en, ru, uk, pl, th)
+### Using custom driver
+If you want to use custom driver, you can do Gdsapi::V2::Client#with_faraday_requester method:
+```ruby
+driver_instance = Faraday.new url: 'https://example.com'
+=> #<Faraday::Connection:0x007fe3bf18be88 @parallel_manager=nil, @headers={"User-Agent"=>"Faraday v0.12.1"}, @params={}, @options=#<Faraday::RequestOptions (empty)>, @ssl=#<Faraday::SSLOptions (empty)>, @default_parallel_manager=nil, @builder=#<Faraday::RackBuilder:0x007fe3bf189c28 @handlers=[Faraday::Request::UrlEncoded, Faraday::Adapter::NetHttp]>, @url_prefix=#<URI::HTTPS https://example.com/>, @proxy=nil>
+Gdsapi::V2::Client.with_requester driver_instance, login: 'login', password: 'password', language: 'en'
+=> #<Gdsapi::V2::Client:0x007fe3c07172e8 @requester=#<Gdsapi::V2::Requester:0x007fe3c07176f8 @driver=#<Faraday::Connection:0x007fe3bf18be88 @parallel_manager=nil, @headers={"User-Agent"=>"Faraday v0.12.1", "Accept-Language"=>"en", "Authorization"=>"Basic bG9naW46cGFzc3dvcmQ="}, @params={}, @options=#<Faraday::RequestOptions (empty)>, @ssl=#<Faraday::SSLOptions (empty)>, @default_parallel_manager=nil, @builder=#<Faraday::RackBuilder:0x007fe3bf189c28 @handlers=[Faraday::Request::UrlEncoded, Faraday::Adapter::NetHttp]>, @url_prefix=#<URI::HTTPS https://example.com/>, @proxy=nil>, @login="login", @password="password", @language="en">>
+```
+available keyword arguments are:
+- :login & :password - HTTP basic auth factors
+- :language - language slug for which request will be performed (available are: en, ru, uk, pl, th)
+
+`driver` instance should respond to:
+- `get(url, params, headers)`
+= `post(url, body, params)`
+- `basic_auth(login, password)`
+- querying and modifying #headers in Hash-style
+
+## Use Gdsapi::V2::Client instance
+### #get_locations
+
+Fetch GDS locations edited after given timestamp. If timestamp is not given, all results are returned in 'upsert' mode.
+
+Returns hash with :upsert and :delete keys, for update or inserting mode and deleting mode respectively. 
+Values for hash are Location objects.
+
+For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get]
+
+keyword args:
+- :country [Number|String] - GDS country id for which locations are fetched (optional)
+- :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+- :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+- :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested) (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT+2)
+
+```ruby
+client.get_locations limit: 5, offset: 15
+=> {:upsert=>[#<Gdsapi::V2::Structs::Location id="3642" name="Кречев" latitude=50.67921380000001 longitude=24.0974334 parent={:id=>"1330"} type={:id=>"6", :name=>"населённый пункт"} sub_type={:id=>"10", :name=>"с."} attributes=[{:id=>"6", :name=>"KOATUU (Ukraine)", :values=>["0721183202"]}]>, #<Gdsapi::V2::Structs::Location id="3643" name="Морозовичи" latitude=50.7066762 longitude=24.1291352 parent={:id=>"1330"} type={:id=>"6", :name=>"населённый пункт"} sub_type={:id=>"10", :name=>"с."} attributes=[{:id=>"6", :name=>"KOATUU (Ukraine)", :values=>["0721183301"]}]>, #<Gdsapi::V2::Structs::Location id="3644" name="Волица-Морозовицкая" latitude=50.7207646 longitude=24.1088641 parent={:id=>"1330"} type={:id=>"6", :name=>"населённый пункт"} sub_type={:id=>"10", :name=>"с."} attributes=[{:id=>"6", :name=>"KOATUU (Ukraine)", :values=>["0721183303"]}]>, #<Gdsapi::V2::Structs::Location id="3645" name="Русовичи" latitude=50.7196979 longitude=24.1388295 parent={:id=>"1330"} type={:id=>"6", :name=>"населённый пункт"} sub_type={:id=>"10", :name=>"с."} attributes=[{:id=>"6", :name=>"KOATUU (Ukraine)", :values=>["0721183305"]}]>, #<Gdsapi::V2::Structs::Location id="3646" name="Мышев" latitude=50.6814711 longitude=24.3183851 parent={:id=>"1330"} type={:id=>"6", :name=>"населённый пункт"} sub_type={:id=>"10", :name=>"с."} attributes=[{:id=>"6", :name=>"KOATUU (Ukraine)", :values=>["0721183401"]}]>]}
+```
+         
+### #get_points
+
+Fetch GDS points edited after given timestamp. If timestamp is not given, all results are returned in 'upsert' mode.
+
+Returns hash with :upsert and :delete keys, for update or inserting mode and deleting mode respectively. 
+Values for hash are Point objects.
+
+For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get]
+
+keyword args:
+- :country [Number|String] - GDS country id for which points are fetched (optional)
+- :location [Number|String] - GDS location id for which points are fetched (optional)
+- :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+- :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+- :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested) (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT+2)
+
+```ruby
+client.get_points limit: 5, offset: 5
+=> {:upsert=>[#<Gdsapi::V2::Structs::Point id="981165" name="Остановка Патинская" latitude=61.577575 longitude=46.304784 parent={:id=>"72788"} address="Остановка Патинская">, #<Gdsapi::V2::Structs::Point id="981166" name="Остановка Перекоп" latitude=61.589032 longitude=46.372445 parent={:id=>"72789"} address="Остановка Перекоп">, #<Gdsapi::V2::Structs::Point id="981157" name="Остановка Микшино" latitude=61.582234 longitude=46.355782 parent={:id=>"72780"} address="Остановка Микшино">, #<Gdsapi::V2::Structs::Point id="981158" name="Остановка Мичкинская" latitude=61.619846 longitude=46.475554 parent={:id=>"7278
+```
+
+
+### #get_countries
+
+Fetch GDS countries
+
+Returns set of Country objects
+
+keyword args:
+- :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+- :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+
+```ruby
+client.get_countries limit: 5, offset: 10
+=> [#<Gdsapi::V2::Structs::Country id="350" name="Пуэрто-Рико" type={:id=>"1", :name=>"страна"} attributes=[{:id=>"2", :name=>"globus_locality_id", :values=>["22160"]}, {:id=>"5", :name=>"FIPS_Code", :values=>["RQ"]}]>, #<Gdsapi::V2::Structs::Country id="351" name="Реюньон" type={:id=>"1", :name=>"страна"} attributes=[{:id=>"2", :name=>"globus_locality_id", :values=>["22084"]}]>, #<Gdsapi::V2::Structs::Country id="352" name="Сен-Бартелеми" type={:id=>"1", :name=>"страна"} attributes=[{:id=>"2", :name=>"globus_locality_id", :values=>["27236"]}, {:id=>"5", :name=>"FIPS_Code", :values=>["TB"]}]>, #<Gdsapi::V2::Structs::Country id="110" name="Мали" type={:id=>"1", :name=>"страна"} attributes=[{:id=>"2", :name=>"globus_locality_id", :values=>["22342"]}, {:id=>"3", :name=>"GENC_2A_Code", :values=>["ML"]}, {:id=>"4", :name=>"GENC_3A_Code", :values=>["MLI"]}]>, #<Gdsapi::V2::Structs::Country id="353" name="О́стров Свято́й Еле́ны" type={:id=>"1", :name=>"страна"} attributes=[{:id=>"2", :name=>"globus_locality_id", :values=>["27895"]}, {:id=>"5", :name=>"FIPS_Code", :values=>["SH"]}]>]
+```
+
+### #get_available trips
+
+Check Availability of trips
+
+Returns set of available dates for specified trip
+
+keyword args:
+- :arrival [String] - GDS arrival point id (required)
+- :departure [String] - GDS departure point id (required)
+- :tickets [Number] - number of tickets for trip (required)
+- :mode [Number] - transport type (optional, buses are: 1,8)
+- :dates [String] - dates for trip (required, format: yyyy-mm-dd, delimiter: ';')
+- :return_only_branded [Boolean] - returns data only for branded trips if true
+
+```ruby
+client.get_available_trips arrival: 'A7CD147C07E7CD1BE040A8C0630328EC', 
+                           departure: 'CA975BC2ACDBCF7FE040B859C14327B3', 
+                           tickets: 2, 
+                           dates: '2017-06-22;2017-06-23'
+=> ["2017-06-22", "2017-06-23"]
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gdsapi"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+Bundler.require :default, :development
+creds = JSON.parse(File.read('credentials.json'))
+@login = creds['login']
+@password = creds['password']
+@host = creds['host']
+
+def driver
+  Faraday.new url: @host
+end
+
+def requester
+  Gdsapi::V2::Requester.new driver, login: @login, password: @password
+end
+
+def client
+  Gdsapi::V2::Client.new requester
+end
+
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+bundle install
+
+# Do any other automated setup that you need to do here
+cp "credentials.json.sample" "credentials.json"

data/credentials.json.sample

@@ -0,0 +1,5 @@
+{
+  "login": "",
+  "password": "",
+  "host": ""
+}

data/gdsapi-v2-ruby.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gdsapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gdsapi-v2-ruby"
+  spec.version       = Gdsapi::V2::VERSION
+  spec.authors       = ["Mike Yurchenkov"]
+  spec.email         = ["mikesehse@gmail.com"]
+
+  spec.summary       = %q{Driver for API.GDS.BUSFOR v2}
+  spec.homepage      = "https://busfor.ru"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+  spec.add_dependency "json", ">= 1.8"
+  spec.add_dependency "dry-struct", "~> 0.3"
+  spec.add_dependency "faraday", ">= 0.9"
+
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "webmock", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 0.49"
+  spec.add_development_dependency "faraday", ">= 0.9"
+end

data/lib/gdsapi.rb

@@ -0,0 +1,22 @@
+Dir[File.expand_path('gdsapi/**/*.rb', __dir__)].each { |file| require file }
+
+# This provides core package manifesto
+## Possible error definitions are provided here
+module Gdsapi
+  module V2
+    # Error thrown on something done wrong on request-side
+    class BadRequestError < StandardError ; end
+    # Error thrown on 401 from GDS
+    class UnathorizedError < BadRequestError ; end
+    # Error thrown on 404 from GDS
+    class NotFoundError < BadRequestError ; end
+    # Error thrown when something is weird with GDS
+    class GdsError < StandardError ; end
+    # Error thrown when Gds returned server-side exception
+    class GdsInternalError < GdsError ; end
+    # Error thrown when GDS returned sudden redirect
+    class GdsRedirectError < GdsError ; end
+    # Error thrown when GDS returned somewhat invalid
+    class MalformedGdsResponse < GdsError ; end
+  end
+end

data/lib/gdsapi/client.rb

@@ -0,0 +1,85 @@
+# Facade class for performing GDS requests
+module Gdsapi
+  module V2
+    class Client
+      attr_reader :requester
+
+      # @param [Gdsapi::V2::Requester] requester - requester instance
+      # It is `strongly recommended` to use Faraday(see ##with_faraday_requester)
+      def initialize(requester)
+        @requester = requester
+      end
+
+      class << self
+        # Constructing routine that uses Faraday as driver
+        # @param base_url: url param for Faraday(requred)
+        # @param login: & password: - HTTP basic auth factors
+        # @param language: - language slug for which request will be performed (available are: en, ru, uk, pl, th)
+        def with_faraday_requester(base_url: nil, login: nil, password: nil, language: nil)
+          driver = Faraday.new(url: base_url)
+          new(Requester.new(driver, login: login, password: password, language: language))
+        end
+
+        # Constructing routine that uses given driver
+        # @param driver - driver instance
+        # @param login: & password: - HTTP basic auth factors
+        # @param language: - language slug for which request will be performed (available are: en, ru, uk, pl, th)
+        def with_requester(driver, login: nil, password: nil, language: nil)
+          new(Requester.new(driver, login: login, password: password, language: language))
+        end
+      end
+
+      # Ad-hoc solution for adding multilanguage support
+      def language=(value)
+        requester.language = value
+      end
+
+      # GDS Method used to fetch GDS locations
+      # For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get]
+      # @param args - keyword args:
+      #                 :country [Number|String] - GDS country id for which locations are fetched (optional)
+      #                 :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+      #                 :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+      #                 :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested)
+      #                                   (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT+2)
+      def get_locations(**args)
+        Methods::GetLocations.new(requester).call(**args)
+      end
+
+      # GDS Method used to fetch GDS points
+      # For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get]
+      # @param args - keyword args:
+      #                 :country [Number|String] - GDS country id for which points are fetched (optional)
+      #                 :location [Number|String] - GDS location id for which points are fetched (optional)
+      #                 :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+      #                 :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+      #                 :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested)
+      #                                   (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT+2)
+      def get_points(**args)
+        Methods::GetPoints.new(requester).call(**args)
+      end
+
+      # GDS Method used to fetch GDS countries
+      # For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-страны-get]
+      # @param args - keyword args:
+      #                 :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+      #                 :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+      def get_countries(**args)
+        Methods::GetCountries.new(requester).call(**args)
+      end
+
+      # GDS Method used to check availability of trips
+      # For more information, see [http://demo.gillbus.com/v2/doc.html#поиск-рейсов-доступность-рейсов-get]
+      # @param args - keyword args:
+      #                 :arrival [String] - GDS arrival point id (required)
+      #                 :departure [String] - GDS departure point id (required)
+      #                 :tickets [Number] - number of tickets for trip (required)
+      #                 :mode [Number] - transport type (optional, buses are: 1,8)
+      #                 :dates [String] - dates for trip (required, format: yyyy-mm-dd, delimiter: ';')
+      #                 :return_only_branded [Boolean] - returns data only for branded trips if true
+      def get_available_trips(**args)
+        Methods::GetAvailableTrips.new(requester).call(**args)
+      end
+    end
+  end
+end

data/lib/gdsapi/methods.rb

@@ -0,0 +1,8 @@
+#TODO: Here provide package documentation
+## This package is used to declare GDS method types
+module Gdsapi
+  module V2
+    module Methods
+    end
+  end
+end

data/lib/gdsapi/methods/base_method.rb

@@ -0,0 +1,104 @@
+require_relative 'utils/parse_utils'
+
+module Gdsapi
+  module V2
+    module Methods
+      class BaseMethod
+        include ParseUtils
+        attr_reader :requester
+
+        # Constructor method for passing requester instance
+        # @param [[Gdsapi::V2::Requester]] - requester instance
+        def initialize(requester)
+          @requester = requester
+        end
+
+        ## Generic entry-point for action
+        ## @param hash_styled `list` and `offset` args used for chunking requests
+        ## @return - parsed results
+        def call(**params)
+          response_body = query params
+          body = JSON.parse response_body
+          parse body
+        rescue JSON::ParserError
+          raise MalformedGdsResponse, "Invalid JSON: #{response_body}"
+        end
+
+        protected
+        # HTTP verb used to query GDS API for method
+        # Defaults to :get
+        # @return [Symbol] - symbolic alias for requester method corresponding to HTTP verb (i.e., :get or :post)
+        def method
+          :get
+        end
+
+        # GDS API path for method
+        # It is required for method to specify path
+        def parse(*args)
+          raise NotImplementedError, 'Parsing is not allowed for abstract method'
+        end
+
+        # GDS API path for method
+        # It is required for method to specify path
+        def path
+          raise NotImplementedError, 'Querying is not allowed for abstract method'
+        end
+
+        # Query routine to be executed while performing action
+        # @param [Hash] args - args used for querying
+        # @return [String] - response body string
+        def query(args)
+          params = transform_params(slice_params(args))
+          response = requester.public_send(method, path, params: params)
+          case response.status
+            when (404)
+              raise NotFoundError, "Not found on #{response.env.url}"
+            when (401)
+              raise UnathorizedError, "Invalid auth on #{response.env.url}"
+            when (400..499)
+              raise BadRequestError, "Bad request on #{response.env.url}: #{response.body.to_s}"
+            when (500..599)
+              raise GdsInternalError, "#{response.status} #{response.body.to_s}"
+            when (300..399)
+              raise GdsRedirectError, "#{response.status} #{response.headers['Location'].to_s}"
+            else
+              response.body
+          end
+        end
+
+
+        # Transform params with accordance to requirements of API
+        # @param [Hash[Symbol => Object]] filtered_params - passed params
+        # @return [Hash[Symbol => Object]] transformed set of params
+        def transform_params(filtered_params)
+          filtered_params
+        end
+
+        # Select params which are allowed in querying for the method
+        # @param [Hash[Symbol => Object]] params - passed params
+        # @return [Hash[Symbol => Object]] params filtered using whitelist (see #permitted_params) and by presence (!nil?)
+        def slice_params(params)
+           params.select { |name, value| permitted_params.include?(name) && value }
+        end
+
+        # whitelist of permitted params
+        # defaults to empty list
+        # @return [Array[Symbol]] - params that are permitted for given instance of method
+        def permitted_params
+          []
+        end
+
+        # Editing geodata modes mapping (GDS -> output)
+        # Used when dealing with temporal data (i.e. given timestamps)
+        # U (upsert) - update or create record
+        # D (delete) - delete record
+        def modes
+          {
+            'U' => :upsert,
+            'D' => :delete,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/methods/get_available_trips.rb

@@ -0,0 +1,34 @@
+# GDS Method class used to check availability of trips
+# For more information, see [http://demo.gillbus.com/v2/doc.html#поиск-рейсов-доступность-рейсов-get]
+module Gdsapi
+  module V2
+    module Methods
+      class GetAvailableTrips < BaseMethod
+        private
+
+        ## Parsing routine to be executed while performing action
+        ## Actually, does nothing
+        ## @param [Array] body - parsed JSON payload from GDS
+        ## @return [Array] set of available dates for given trip
+        def parse(body)
+          body
+        end
+
+        def path
+          'available_trips'
+        end
+
+        # Query params
+        # :arrival [String] - GDS arrival point id (required)
+        # :departure [String] - GDS departure point id (required)
+        # :tickets [Number] - number of tickets for trip (required)
+        # :mode [Number] - transport type (optional, buses are: 1,8)
+        # :dates [String] - dates for trip (required, format: yyyy-mm-dd, delimiter: ';')
+        # :return_only_branded [Boolean] - returns data only for branded trips if true
+        def permitted_params
+          %i(arrival departure tickets mode dates return_only_branded)
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/methods/get_countries.rb

@@ -0,0 +1,43 @@
+# GDS Method class used to fetch GDS countries
+# For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-страны-get]
+module Gdsapi
+  module V2
+    module Methods
+      class GetCountries < BaseMethod
+
+        private
+
+        def path
+          'countries'
+        end
+
+        ## Parsing routine to be executed while performing action
+        ## @param [Hash] body - parsed JSON payload from GDS
+        ## @return [Array[Gdsapi::V2::Structs::Country]] parsed set of countries
+        def parse(body)
+          return [] if body.empty?
+
+          countries = body['countries']
+          types = body['types']
+          attributes = body['attributes']
+          countries.map do |country|
+            args = {
+              id: country['id'],
+              name: country['name'],
+              type: types.find { |type| type['id'] == country['type_id'] },
+              attributes: match_attributes(country['attributes'], attributes),
+            }
+            Gdsapi::V2::Structs::Country.new args
+          end
+        end
+
+        # Query params
+        # :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+        # :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+        def permitted_params
+          %i(limit offset])
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/methods/get_locations.rb

@@ -0,0 +1,70 @@
+# GDS Method class used to fetch GDS locations
+# For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-населенных-пунктов-get]
+module Gdsapi
+  module V2
+    module Methods
+      class GetLocations < BaseMethod
+
+        private
+
+        # Parsing routine invoked on JSON response parsed to hash
+        # @param [Hash] body - given response hash from GDS
+        # @return [Hash[Symbol => Array[Gdsapi::V2::Structs::Location]]] - location objects grouped by editing mode:
+        #    :upsert - objects inserted or updated since given timestamp
+        #    :delete - objects deleted since given timestamp
+        def parse(body)
+          return {} if body.empty?
+
+          locations = body['locations']
+          types = body['types']
+          attributes = body['attributes']
+          sub_types = body['subTypes']
+          grouped_locations = locations.group_by { |location| location['mod'] }
+          parsed_locations = grouped_locations.map do |mod, hash_locations|
+            parsed_locations = hash_locations.map do |location|
+              args = {
+                  id: location['id'],
+                  name: location['name'],
+                  latitude: location['latitude'],
+                  longitude: location['longitude'],
+                  parent: location['parent'],
+                  type: types.find { |type| type['id'] == location['type_id'] },
+                  sub_type: sub_types.find { |sub_type| sub_type['id'] == location['sub_type_id'] },
+                  attributes: match_attributes(location['attributes'], attributes),
+              }
+              Gdsapi::V2::Structs::Location.new args
+            end
+            [modes[mod], parsed_locations]
+          end
+          Hash[parsed_locations]
+        end
+
+        def path
+          'locations'
+        end
+
+        def transform_params(filtered_params)
+          filtered_params.tap do |params|
+            if params[:timestamp]
+              if params[:timestamp].respond_to?(:strftime)
+                params[:timestamp] = params[:timestamp].strftime('%FT%T%z')
+              else
+                params[:timestamp] = params[:timestamp].to_s
+              end
+            end
+          end
+        end
+
+        # Query params
+        # :country [Number|String] - GDS country id for which locations are fetched (optional)
+        # :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+        # :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+        # :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested)
+        #                                   (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT +2)
+        def permitted_params
+          %i(country offset limit timestamp)
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/methods/get_points.rb

@@ -0,0 +1,68 @@
+# GDS Method class used to fetch GDS locations
+# For more information, see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get]
+module Gdsapi
+  module V2
+    module Methods
+      class GetPoints < BaseMethod
+
+        private
+
+        # Parsing routine invoked on JSON response parsed to hash
+        # @param [Hash] body - given response hash from GDS
+        # @return [Hash[Symbol => Array[Gdsapi::V2::Structs::Point]]] - point objects grouped by editing mode:
+        #    :upsert - objects inserted or updated since given timestamp
+        #    :delete - objects deleted since given timestamp
+        def parse(body)
+          return {} if body.empty?
+
+          points = body['points']
+          attributes = body['attributes']
+          grouped_points = points.group_by { |point| point['mod'] }
+          parsed_points = grouped_points.map do |mod, hash_points|
+            parsed_points = hash_points.map do |point|
+              args = {
+                  id: point['id'],
+                  name: point['name'],
+                  latitude: point['latitude'],
+                  longitude: point['longitude'],
+                  parent: point['parent'],
+                  address: point['address'],
+                  attributes: match_attributes(point['attributes'], attributes),
+              }
+              Gdsapi::V2::Structs::Point.new args
+            end
+            [modes[mod], parsed_points]
+          end
+          Hash[parsed_points]
+        end
+
+        def path
+          'points'
+        end
+
+        def transform_params(filtered_params)
+          filtered_params.tap do |params|
+            if params[:timestamp]
+              if params[:timestamp].respond_to?(:strftime)
+                params[:timestamp] = params[:timestamp].strftime('%FT%T%z')
+              else
+                params[:timestamp] = params[:timestamp].to_s
+              end
+            end
+          end
+        end
+
+        # Query params
+        # :country [Number|String] - GDS country id for which points are fetched (optional)
+        # :location [Number|String] - GDS location id for which points are fetched (optional)
+        # :offset [Number|String] - number of records to be skipped when fetching chunks (optional)
+        # :limit [Number|String] - number of records to be fetched when fetching chunks (optional)
+        # :timestamp [String] - temporal checkpoint(i.e. date, records from which are interested)
+        #                                   (optional, format: yyyy-MM-dd’T’HH:mm:ssZ, GMT +2)
+        def permitted_params
+          %i(country location offset limit timestamp)
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/methods/utils/parse_utils.rb

@@ -0,0 +1,32 @@
+# Module representing parsing utility methods
+module Gdsapi
+  module V2
+    module Methods
+      module ParseUtils
+        ## Helping routine for matching given attributes with dictionary
+        ## @param set [Array[Hash] | nil] - set of {'id', 'value'}-ish attributes for country
+        ## @param dictionary [Array[Hash]] - dictionary of {'id', 'name'}-ish attributes
+        ## @return [Array[Hash]|nil] - {id:, name:, value:}-ish attributes hash if set is present, nil otherwise
+        def match_attributes(set, dictionary)
+          return unless set
+
+          grouped_set = set.group_by { |attribute| attribute['id'] }
+          grouped_set.map do |id, set_attributes|
+            dictionary_attribute = dictionary.find {|dict_attr| dict_attr['id'] == id }
+            values = set_attributes.map { |set_attribute| set_attribute['value'] }
+            if dictionary_attribute
+              {
+                id: dictionary_attribute['id'],
+                name: dictionary_attribute['name'],
+                values: values,
+              }
+            else
+              raise MalformedGdsResponse,
+                "Invalid response: missing attribute #{id}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/requester.rb

@@ -0,0 +1,53 @@
+# Requester class
+# Encapsulates supportive data to be used when querying
+# Also responsible for performing HTTP requests
+module Gdsapi
+  module V2
+    class Requester
+      attr_reader :login
+      attr_reader :password
+      attr_reader :driver
+      attr_reader :language
+
+      # @param [Faraday::Connection] driver - driver instance, i.e. object that responds to
+      #                 #get(url, params, headers),
+      #                 #post(url, body, params),
+      #                 #basic_auth(login, password),
+      #                 and querying and modifying #headers in Hash-style
+      # It is `strongly recommended` to use Faraday
+      # @param               login: & password: - HTTP basic auth factors
+      # @param              language: - language slug for which request will be performed
+      def initialize(driver, login: '', password: '', language: 'ru')
+        @driver = driver
+        @login = login || ''
+        @password = password || ''
+        @language = language || 'ru'
+        set_language
+        set_basic_auth
+      end
+
+      def language=(value)
+        @language = value
+        set_language
+      end
+
+      def get(url, params: {}, headers: {})
+        driver.get url, params, headers
+      end
+
+      def post(url, body: {}, headers: {})
+        driver.post url, body, headers
+      end
+
+      private
+
+      def set_language
+        driver.headers['Accept-Language'] = language
+      end
+
+      def set_basic_auth
+        driver.basic_auth login, password
+      end
+    end
+  end
+end

data/lib/gdsapi/structs.rb

@@ -0,0 +1,19 @@
+require 'dry-struct'
+#TODO: Here provide package documentation
+## This package is used to declare struct types expected from GDS
+## dry-struct is used in order to provide type definitions and flexible coercions mechanism
+module Gdsapi
+  module V2
+    module Structs
+      include Dry::Types.module
+
+      Attributes = Structs::Array.member(Structs::Hash.symbolized(id: Structs::Coercible::Int,
+                     name: Structs::Coercible::String,
+                     values: Structs::Array.member(Structs::Coercible::String)))
+
+      Type = Structs::Hash.symbolized(id: Structs::Coercible::Int, name: Structs::Coercible::String)
+
+      Parent = Structs::Hash.symbolized(id: Structs::Coercible::Int)
+    end
+  end
+end

data/lib/gdsapi/structs/country.rb

@@ -0,0 +1,24 @@
+require_relative '../structs'
+
+## Country struct
+## Used when syncing geodata with GDS
+## See [Gdsapi::V2::Methods::GetCountries] for details
+## Also see http://demo.gillbus.com/v2/doc.html#получение-географии-страны for schema definition
+module Gdsapi
+  module V2
+    module Structs
+      class Country < Dry::Struct
+        attribute :id, Structs::Coercible::Int
+        attribute :name, Structs::Coercible::String
+        attribute :type, Type.optional
+        attribute :attributes, Attributes.optional
+
+        def attribute_by_id(id)
+          if attributes && id
+            attributes.find {|attribute| attribute.id == id}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/structs/location.rb

@@ -0,0 +1,26 @@
+## Country struct
+## Used when syncing geodata with GDS
+## See [[Gdsapi::V2::Methods::GetLocations]] for details
+## Also see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-населенных-пунктов-get] for schema definition
+module Gdsapi
+  module V2
+    module Structs
+      class Location < Dry::Struct
+        attribute :id, Structs::Coercible::Int
+        attribute :name, Structs::Coercible::String
+        attribute :latitude, Structs::Coercible::Float
+        attribute :longitude, Structs::Coercible::Float
+        attribute :parent, Parent.optional
+        attribute :type, Type.optional
+        attribute :sub_type, Type.optional
+        attribute :attributes, Attributes.optional
+
+        def attribute_by_id(id)
+          if attributes && id
+            attributes.find {|attribute| attribute.id == id}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gdsapi/structs/point.rb

@@ -0,0 +1,18 @@
+## Point struct
+## Used when syncing geodata with GDS
+## See [[Gdsapi::V2::Methods::GetPoints]] for details
+## Also see [http://demo.gillbus.com/v2/doc.html#получение-географии-получение-списка-остановок-get] for schema definition
+module Gdsapi
+  module V2
+    module Structs
+      class Point < Dry::Struct
+        attribute :id, Structs::Coercible::Int
+        attribute :name, Structs::Coercible::String
+        attribute :latitude, Structs::Coercible::Float
+        attribute :longitude, Structs::Coercible::Float
+        attribute :parent, Parent.optional
+        attribute :address, Structs::Coercible::String
+      end
+    end
+  end
+end

data/lib/gdsapi/version.rb

@@ -0,0 +1,5 @@
+module Gdsapi
+  module V2
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: gdsapi-v2-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Yurchenkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email:
+- mikesehse@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- credentials.json.sample
+- gdsapi-v2-ruby.gemspec
+- lib/gdsapi.rb
+- lib/gdsapi/client.rb
+- lib/gdsapi/methods.rb
+- lib/gdsapi/methods/base_method.rb
+- lib/gdsapi/methods/get_available_trips.rb
+- lib/gdsapi/methods/get_countries.rb
+- lib/gdsapi/methods/get_locations.rb
+- lib/gdsapi/methods/get_points.rb
+- lib/gdsapi/methods/utils/parse_utils.rb
+- lib/gdsapi/requester.rb
+- lib/gdsapi/structs.rb
+- lib/gdsapi/structs/country.rb
+- lib/gdsapi/structs/location.rb
+- lib/gdsapi/structs/point.rb
+- lib/gdsapi/version.rb
+homepage: https://busfor.ru
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Driver for API.GDS.BUSFOR v2
+test_files: []