gdsapi-v2-ruby 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c781b442dc46eb87b3679ea913b7805c4c32b377
-  data.tar.gz: 9e9c8735c65d9e44558ce37d1766e3dd43352c9f
+  metadata.gz: 682cc9ed559e0b6ac5d9af4074e5341b4b5d7c3a
+  data.tar.gz: 62b93de7d2a463f4a77d818068570ae0a066301c
 SHA512:
-  metadata.gz: 5e28af36aea0cca34133980851bdcd3b5d509b74d3a58c259affdbc0af28d56d0db6c3344a1207ff8a1296a43832dae5a71ded156bbc22b654fd7bed28a3f811
-  data.tar.gz: 298a8b3a496e1e2577199d3b405cc9338bbb164a606c61ad5fd488d789e4c002199bdff9bdf05a9f33ecc37ad35fd280ce0a3a8e5dc6876b0c1895e12acdcae2
+  metadata.gz: 430c0da15dab2bb293d415e9b30f740048ebe3e1a118c33d3c34b15805104ea54371ea8c00df23c4212421a2380da81257aa85ff6d17c82ed2c6a8c14f2c372e
+  data.tar.gz: 681427cad7b61007cf738f8017dc01498714da4f4afb89d76cd6ab8635dbad071e9cc87efd7b4700f5b04b96c34ba09876979c7ed09c2643ba76f300d9d058dd

data/gdsapi-v2-ruby.gemspec

@@ -5,7 +5,7 @@ require 'gdsapi/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "gdsapi-v2-ruby"
-  spec.version       = Gdsapi::V2::VERSION
+  spec.version       = Gdsapi::VERSION
   spec.authors       = ["Mike Yurchenkov"]
   spec.email         = ["mikesehse@gmail.com"]
 

data/lib/gdsapi/client.rb

@@ -1,85 +1,83 @@
 # Facade class for performing GDS requests
 module Gdsapi
-  module V2
-    class Client
-      attr_reader :requester
+  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
+    # @param [Gdsapi::Requester] requester - requester instance
+    # It is `strongly recommended` to use Faraday(see ##with_faraday_requester)
+    def initialize(requester)
+      @requester = requester
+    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
+    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
 
-      # Ad-hoc solution for adding multilanguage support
-      def language=(value)
-        requester.language = value
+      # 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
 
-      # 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
+    # Ad-hoc solution for adding multilanguage support
+    def language=(value)
+      requester.language = value
+    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 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 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 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 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
+    # 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

data/lib/gdsapi/methods/base_method.rb

@@ -1,103 +1,101 @@
 require_relative 'utils/parse_utils'
 
 module Gdsapi
-  module V2
-    module Methods
-      class BaseMethod
-        include ParseUtils
-        attr_reader :requester
+  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
+      # Constructor method for passing requester instance
+      # @param [[Gdsapi::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
+      ## 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
+      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 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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

data/lib/gdsapi/methods/get_available_trips.rb

@@ -1,33 +1,31 @@
 # 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
+  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
+      ## 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
+      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
+      # 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

data/lib/gdsapi/methods/get_countries.rb

@@ -1,42 +1,40 @@
 # 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
+  module Methods
+    class GetCountries < BaseMethod
 
-        private
+      private
 
-        def path
-          'countries'
-        end
+      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?
+      ## Parsing routine to be executed while performing action
+      ## @param [Hash] body - parsed JSON payload from GDS
+      ## @return [Array[Gdsapi::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
+        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::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
+      # 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

data/lib/gdsapi/methods/get_locations.rb

@@ -1,69 +1,67 @@
 # 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
+  module Methods
+    class GetLocations < BaseMethod
 
-        private
+      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?
+      # Parsing routine invoked on JSON response parsed to hash
+      # @param [Hash] body - given response hash from GDS
+      # @return [Hash[Symbol => Array[Gdsapi::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]
+        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::Structs::Location.new args
           end
-          Hash[parsed_locations]
+          [modes[mod], parsed_locations]
         end
+        Hash[parsed_locations]
+      end
 
-        def path
-          '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
+      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
+      # 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

data/lib/gdsapi/methods/get_points.rb

@@ -1,67 +1,65 @@
 # 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
+  module Methods
+    class GetPoints < BaseMethod
 
-        private
+      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?
+      # Parsing routine invoked on JSON response parsed to hash
+      # @param [Hash] body - given response hash from GDS
+      # @return [Hash[Symbol => Array[Gdsapi::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]
+        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::Structs::Point.new args
           end
-          Hash[parsed_points]
+          [modes[mod], parsed_points]
         end
+        Hash[parsed_points]
+      end
 
-        def path
-          '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
+      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
+      # 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

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

@@ -1,32 +1,30 @@
 # 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
+  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
+        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/methods.rb

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

data/lib/gdsapi/requester.rb

@@ -2,52 +2,50 @@
 # 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
+  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
+    # @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 language=(value)
+      @language = value
+      set_language
+    end
 
-      def get(url, params: {}, headers: {})
-        driver.get url, params, headers
-      end
+    def get(url, params: {}, headers: {})
+      driver.get url, params, headers
+    end
 
-      def post(url, body: {}, headers: {})
-        driver.post url, body, headers
-      end
+    def post(url, body: {}, headers: {})
+      driver.post url, body, headers
+    end
 
-      private
+    private
 
-      def set_language
-        driver.headers['Accept-Language'] = language
-      end
+    def set_language
+      driver.headers['Accept-Language'] = language
+    end
 
-      def set_basic_auth
-        driver.basic_auth login, password
-      end
+    def set_basic_auth
+      driver.basic_auth login, password
     end
   end
 end

data/lib/gdsapi/structs/country.rb

@@ -2,21 +2,19 @@ require_relative '../structs'
 
 ## Country struct
 ## Used when syncing geodata with GDS
-## See [Gdsapi::V2::Methods::GetCountries] for details
+## See [Gdsapi::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
+  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
+      def attribute_by_id(id)
+        if attributes && id
+          attributes.find {|attribute| attribute.id == id}
         end
       end
     end

data/lib/gdsapi/structs/location.rb

@@ -1,24 +1,22 @@
 ## Country struct
 ## Used when syncing geodata with GDS
-## See [[Gdsapi::V2::Methods::GetLocations]] for details
+## See [[Gdsapi::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
+  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
+      def attribute_by_id(id)
+        if attributes && id
+          attributes.find {|attribute| attribute.id == id}
         end
       end
     end

data/lib/gdsapi/structs/point.rb

@@ -1,18 +1,16 @@
 ## Point struct
 ## Used when syncing geodata with GDS
-## See [[Gdsapi::V2::Methods::GetPoints]] for details
+## See [[Gdsapi::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
+  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

data/lib/gdsapi/structs.rb

@@ -3,17 +3,15 @@ require 'dry-struct'
 ## 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
+  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)))
+    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)
+    Type = Structs::Hash.symbolized(id: Structs::Coercible::Int, name: Structs::Coercible::String)
 
-      Parent = Structs::Hash.symbolized(id: Structs::Coercible::Int)
-    end
+    Parent = Structs::Hash.symbolized(id: Structs::Coercible::Int)
   end
 end

data/lib/gdsapi/version.rb

@@ -1,5 +1,3 @@
 module Gdsapi
-  module V2
-    VERSION = "0.1.3"
-  end
+  VERSION = "0.1.4"
 end

data/lib/gdsapi.rb

@@ -3,20 +3,18 @@ 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
+  # 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gdsapi-v2-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Mike Yurchenkov