kudago-client 0.8.0 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d172d4306e2c5302513269cedda202a5d819ec3e49d5ccfd43bdf08b43ce145e
-  data.tar.gz: 3377bb184b176245a1989fd7c6aaf7fce7566820da183474cfa1e09cd2ed51f8
+  metadata.gz: a064b20ce3e42cac11a30427e80e410ba5cba33d4f54daeba36e6565cdc4a3da
+  data.tar.gz: 6f7fee6b4cf5fd59973546e25069d6d64df7f74bd18434e1cc9baec3024e9b86
 SHA512:
-  metadata.gz: e42d427a3ad2145c895be7f6efdae423c3873520c50b77f35e8d81681e237d066152acdc685259cfa3b289fd44f0e6148880196f37fbe383314581cecb58b94f
-  data.tar.gz: dea42a306ad020a78fb0fbba888d34d4a853cb7471678bfc1bddd4044dfbe6c90326e504282c44f79b5fcc4d113079bfb2c6dac189a8fabedbbd9f8e759cad74
+  metadata.gz: 556dcfc8a75ed780da3524e9169fa0638cc22ab658fed50a425efa28cf0d00b3ad6fa10a4162af820b6a5021a9dc15c978e8bcc7ba3a1b26c192ef587b06cd66
+  data.tar.gz: da9ee8fb91f303efade8b47d9c145ab999b6c8094080c525fd0c807e7955f79768840629e58b7a02119def3e4bcd1d7aa29192f0a81ce07e0bd52f40466b9ae7

data/CHANGELOG.md

@@ -14,3 +14,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 ### Added
 
 - all requests from [kudago api](https://docs.kudago.com/api/#)
+
+
+## [1.0] - 2025.09.06
+
+### Added
+
+- client's methods to get next/previous page for list
+- setting for default language for client
+- dependency of activesupport
+- Entities::Agent#participations returns `Participation` struct
+
+### Changed
+
+- CI split into lint and test

data/README.md

@@ -1,11 +1,107 @@
 # KudagoClient
 
+API client for [kudago api](https://docs.kudago.com/api/#)
+
 ## Installation
 
+Just add this line to your Gemfile
+
+```ruby
+gem "kudago-client"
+```
+
+And then (I'll fix it, like autoload or smt)
+```ruby
+require "kudago_client"
+```
+
 ## Usage
 
+This is an open API, so no key is required
+
+
+### Client
+
+id/slug is required, params isn't required
+
+```ruby
+client = KudagoClient::Client.new(lang: "ru")
+
+# get entity
+client.agent(agent_id, {}) # KudagoClient::Entities::Agent
+client.location(slug, {}) # KudagoClient::Entities::Location
+client.role(role_id, {}) # KudagoClient::Entities::Role
+client.event_category(event_category_id, {}) # KudagoClient::Entities::EventCategory
+client.place_category(place_category_id, {}) # KudagoClient::Entities::PlaceCategory
+client.movie(movie_id, {}) # KudagoClient::Entities::Movie
+client.showing(showing_id, {}) # KudagoClient::Entities::MovieShowing
+client.place(place_id, {}) # KudagoClient::Entities::Place
+client.piece_news(news_id, {}) # KudagoClient::Entities::News
+client.news_comment(news_id, comment_id, {}) # KudagoClient::Entities::Comment
+client.event(event_id, {}) # KudagoClient::Entities::Event
+client.event_comment(event_id, comment_id, {}) # KudagoClient::Entities::Comment
+client.list(list_id, {}) # KudagoClient::Entities::List
+client.list_comment(list_id, comment_id, {}) # KudagoClient::Entities::Comment
+
+# get entity list
+client.agents({}) # KudagoClient::EntitiesList::AgentList
+client.locations({}) # KudagoClient::EntitiesList::LocationList
+client.roles({}) # KudagoClient::EntitiesList::RoleList
+client.event_categories({}) # KudagoClient::EntitiesList::EventCategoriesList
+client.place_categories({}) # KudagoClient::EntitiesList::PlaceCategoriesList
+client.movies({}) # KudagoClient::EntitiesList::MovieList
+client.movie_comments(movie_id, {}) # KudagoClient::EntitiesList::CommentList
+client.showings({}) # KudagoClient::EntitiesList::MovieShowingList
+client.movie_showings(movie_id, {}) # KudagoClient::EntitiesList::MovieShowingList
+client.places({}) # KudagoClient::EntitiesList::PlaceList
+client.place_comments(place_id, {}) # KudagoClient::EntitiesList::CommentList
+client.news({}) # KudagoClient::EntitiesList::NewsList
+client.news_comments(news_id, {}) # KudagoClient::EntitiesList::CommentList
+client.events({}) # KudagoClient::EntitiesList::EventList
+client.event_comments(event_id, {}) # KudagoClient::EntitiesList::CommentList
+client.events_of_the_day({}) # KudagoClient::EntitiesList::EventList
+client.lists({}) # KudagoClient::EntitiesList::ListList
+client.list_comments(list_id, {}) # KudagoClient::EntitiesList::CommentList
+client.search(query, {}) # KudagoClient::EntitiesList::MultipleList
+
+# get another page of list
+client.next_page(list, {})
+client.previous_page(list, {})
+```
+
+
+### Lists
+
+```ruby
+list = KudagoClient::EntitiesList::BaseList.new
+
+list.count # get count of all items
+list.next_url # url to next page
+list.previous_url # url to previous page
+list.items # items on page
+list.lang # lang of request
+```
+
+
+### Error
+
+```ruby
+begin
+    KudagoClient::Client.new.search("new", {page: 999}) # KudagoClient::Error
+rescue KudagoClient::Error => error
+    error.message # "Неправильная страница"
+    error.status # 404
+    error.reason # "Not Found"
+end
+```
+
 ## Development
 
+You can contribute to this gem :)
+
+Just fork the repo and then make PR
+
+I wrote a simple [To Do list](./to_do.md)
 
 ## Contributing
 

data/lib/kudago_client/client.rb

@@ -13,6 +13,7 @@ require_relative "requests/event_request"
 require_relative "requests/event_of_the_day_request"
 require_relative "requests/list_request"
 require_relative "requests/search_request"
+require_relative "requests/base_request"
 
 require_relative "entities/location"
 require_relative "entities/agent"
@@ -43,182 +44,203 @@ require_relative "entities_list/multiple_list"
 
 module KudagoClient
   class Client
-    attr_accessor :api_version
+    attr_accessor :lang
 
-    LANG = "ru"
+    class << self
+      attr_accessor :default_lang
 
-    def initialize(lang: LANG)
-      @api_version = api_version
-      @lang = lang
+      def config &blk
+        blk.call(self) if block_given?
+      end
+    end
+
+    def initialize(lang: nil)
+      @lang = lang || self.class.default_lang
+    end
+
+    # PAGE METHODS
+
+    def next_page(list, params = {})
+      return nil if list.next_url.nil?
+
+      res = Requests::BaseRequest.get(list.next_url, params)
+      list.class.new(**res.data, lang: entity_lang(params))
+    end
+
+    def previous_page(list, params = {})
+      return nil if list.previous_url.nil?
+
+      res = Requests::BaseRequest.get(list.previous_url, params)
+      list.class.new(**res.data, lang: entity_lang(params))
     end
 
     # ENTITY METHODS
 
     def agent(agent_id, params = {})
       res = Requests::AgentRequest.find(agent_id, params)
-      KudagoClient::Entities::Agent.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Agent.new(**res.data, lang: entity_lang(params))
     end
 
     def location(slug, params = {})
       res = Requests::LocationRequest.find(slug, params)
-      KudagoClient::Entities::Location.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Location.new(**res.data, lang: entity_lang(params))
     end
 
     def role(role_id, params = {})
       res = Requests::RoleRequest.find(role_id, params)
-      KudagoClient::Entities::Role.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Role.new(**res.data, lang: entity_lang(params))
     end
 
     def event_category(event_category_id, params = {})
       res = Requests::EventCategoryRequest.find(event_category_id, params)
-      KudagoClient::Entities::EventCategory.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::EventCategory.new(**res.data, lang: entity_lang(params))
     end
 
     def place_category(place_category_id, params = {})
       res = Requests::PlaceCategoryRequest.find(place_category_id, params)
-      KudagoClient::Entities::PlaceCategory.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::PlaceCategory.new(**res.data, lang: entity_lang(params))
     end
 
     def movie(movie_id, params = {})
       res = Requests::MovieRequest.find(movie_id, params)
-      KudagoClient::Entities::Movie.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Movie.new(**res.data, lang: entity_lang(params))
     end
 
     def showing(showing_id, params = {})
       res = Requests::MovieShowingRequest.find(showing_id, params)
-      KudagoClient::Entities::MovieShowing.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::MovieShowing.new(**res.data, lang: entity_lang(params))
     end
 
     def place(place_id, params = {})
       res = Requests::PlaceRequest.find(place_id, params)
-      KudagoClient::Entities::Place.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Place.new(**res.data, lang: entity_lang(params))
     end
 
     def piece_news(news_id, params = {})
       res = Requests::NewsRequest.find(news_id, params)
-      KudagoClient::Entities::News.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::News.new(**res.data, lang: entity_lang(params))
     end
 
     def news_comment(news_id, comment_id, params = {})
       res = Requests::NewsRequest.comment(news_id, comment_id, params)
-      KudagoClient::Entities::Comment.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Comment.new(**res.data, lang: entity_lang(params))
     end
 
     def event(event_id, params = {})
       res = Requests::EventRequest.find(event_id, params)
-      KudagoClient::Entities::Event.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Event.new(**res.data, lang: entity_lang(params))
     end
 
     def event_comment(event_id, comment_id, params = {})
       res = Requests::EventRequest.comment(event_id, comment_id, params)
-      KudagoClient::Entities::Comment.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Comment.new(**res.data, lang: entity_lang(params))
     end
 
     def list(list_id, params = {})
       res = Requests::ListRequest.find(list_id, params)
-      KudagoClient::Entities::List.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::List.new(**res.data, lang: entity_lang(params))
     end
 
     def list_comment(list_id, comment_id, params = {})
       res = Requests::ListRequest.comment(list_id, comment_id, params)
-      KudagoClient::Entities::Comment.new(**res, lang: entity_lang(params))
+      KudagoClient::Entities::Comment.new(**res.data, lang: entity_lang(params))
     end
 
     # LIST METHODS
 
     def agents(params = {})
       res = Requests::AgentRequest.list(params)
-      KudagoClient::EntitiesList::AgentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::AgentList.new(**res.data, lang: entity_lang(params))
     end
 
     def locations(params = {})
       res = Requests::LocationRequest.list(params)
-      KudagoClient::EntitiesList::LocationList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::LocationList.new(**res.data, lang: entity_lang(params))
     end
 
     def roles(params = {})
       res = Requests::RoleRequest.list(params)
-      KudagoClient::EntitiesList::RoleList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::RoleList.new(**res.data, lang: entity_lang(params))
     end
 
     def event_categories(params = {})
       res = Requests::EventCategoryRequest.list(params)
-      KudagoClient::EntitiesList::EventCategoriesList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::EventCategoriesList.new(**res.data, lang: entity_lang(params))
     end
 
     def place_categories(params = {})
       res = Requests::PlaceCategoryRequest.list(params)
-      KudagoClient::EntitiesList::PlaceCategoriesList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::PlaceCategoriesList.new(**res.data, lang: entity_lang(params))
     end
 
     def movies(params = {})
       res = Requests::MovieRequest.list(params)
-      KudagoClient::EntitiesList::MovieList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::MovieList.new(**res.data, lang: entity_lang(params))
     end
 
     def movie_comments(movie_id, params = {})
       res = Requests::MovieRequest.comments(movie_id, params)
-      KudagoClient::EntitiesList::CommentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::CommentList.new(**res.data, lang: entity_lang(params))
     end
 
     def showings(params = {})
       res = Requests::MovieShowingRequest.list(params)
-      KudagoClient::EntitiesList::MovieShowingList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::MovieShowingList.new(**res.data, lang: entity_lang(params))
     end
 
     def movie_showings(movie_id, params = {})
       res = Requests::MovieRequest.showings(movie_id, params)
-      KudagoClient::EntitiesList::MovieShowingList.new(**res, item_params: {movie: {id: movie_id}}, lang: entity_lang(params))
+      KudagoClient::EntitiesList::MovieShowingList.new(**res.data, item_params: {movie: {id: movie_id}}, lang: entity_lang(params))
     end
 
     def places(params = {})
       res = Requests::PlaceRequest.list(params)
-      KudagoClient::EntitiesList::PlaceList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::PlaceList.new(**res.data, lang: entity_lang(params))
     end
 
     def place_comments(place_id, params = {})
       res = Requests::PlaceRequest.comments(place_id, params)
-      KudagoClient::EntitiesList::CommentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::CommentList.new(**res.data, lang: entity_lang(params))
     end
 
     def news(params = {})
       res = Requests::NewsRequest.list(params)
-      KudagoClient::EntitiesList::NewsList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::NewsList.new(**res.data, lang: entity_lang(params))
     end
 
     def news_comments(news_id, params = {})
       res = Requests::NewsRequest.comments(news_id, params)
-      KudagoClient::EntitiesList::CommentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::CommentList.new(**res.data, lang: entity_lang(params))
     end
 
     def events(params = {})
       res = Requests::EventRequest.list(params)
-      KudagoClient::EntitiesList::EventList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::EventList.new(**res.data, lang: entity_lang(params))
     end
 
     def event_comments(event_id, params = {})
       res = Requests::EventRequest.comments(event_id, params)
-      KudagoClient::EntitiesList::CommentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::CommentList.new(**res.data, lang: entity_lang(params))
     end
 
     def events_of_the_day(params = {})
       res = Requests::EventOfTheDayRequest.list(params)
-      KudagoClient::EntitiesList::EventList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::EventList.new(**res.data, lang: entity_lang(params))
     end
 
     def lists(params = {})
       res = Requests::ListRequest.list(params)
-      KudagoClient::EntitiesList::ListList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::ListList.new(**res.data, lang: entity_lang(params))
     end
 
     def list_comments(list_id, params = {})
       res = Requests::ListRequest.comments(list_id, params)
-      KudagoClient::EntitiesList::CommentList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::CommentList.new(**res.data, lang: entity_lang(params))
     end
 
     def search(query, params = {})
       res = Requests::SearchRequest.search(query, params)
-      KudagoClient::EntitiesList::MultipleList.new(**res, lang: entity_lang(params))
+      KudagoClient::EntitiesList::MultipleList.new(**res.data, lang: entity_lang(params))
     end
 
     private

data/lib/kudago_client/connection.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "faraday"
 require "oj"
 
+require_relative "version"
+
 module KudagoClient
   class Connection
     BASE_URL = "https://kudago.com/public-api/v1.4/"

data/lib/kudago_client/entities/agent.rb

@@ -20,6 +20,8 @@ module KudagoClient
       # rank - рейтинг объекта
       # participations - список участий агента
 
+      Participation = Struct.new(:role, :event)
+
       attr_reader :lang, :id, :title, :slug, :favorites_count, :comments_count, :description, :body_text,
         :site_url, :disable_comments, :ctype, :images, :agent_type, :rank, :participations, :text_format, :is_stub
 
@@ -39,7 +41,6 @@ module KudagoClient
         @disable_comments = disable_comments
         @favorites_count = favorites_count
         @is_stub = is_stub
-        @participations = participations # participant entity ???
         @rank = rank
         @site_url = site_url
         @slug = slug
@@ -49,6 +50,12 @@ module KudagoClient
         @images = images&.map do |image|
           KudagoClient::Entities::Image.new(image: image[:image], thumbnails: image[:thumbnails], source: image[:source])
         end
+        @participations = participations&.map do |participation|
+          Participation.new(
+            Role.new(**participation[:role], lang: lang),
+            (participation[:item][:ctype] == "event") ? Event.new(**participation[:item].except(:ctype), lang: lang) : nil
+          )
+        end
       end
     end
   end

data/lib/kudago_client/entities_list/base_list.rb

@@ -5,8 +5,8 @@ module KudagoClient
 
       def initialize(count:, next_url:, previous_url:, results:, lang: "ru", item_params: {})
         @count = count
-        @next = next_url
-        @previous = previous_url
+        @next_url = next_url
+        @previous_url = previous_url
         @lang = lang
 
         @items = results.map do |item|

data/lib/kudago_client/requests/agent_request.rb

@@ -9,7 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :text_format, :ids, :fields, :agent_type, :expand, :tags)
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(agent_id, params = {})

data/lib/kudago_client/requests/base_request.rb

@@ -1,7 +1,8 @@
 require_relative "../connection"
 require_relative "../error"
+require_relative "../response"
 
-require "active_support/core_ext/hash"
+require "active_support/core_ext/hash/slice"
 
 module KudagoClient
   module Requests
@@ -10,7 +11,7 @@ module KudagoClient
         response = connection.get(path, params)
 
         if response.success?
-          response.body
+          Response.new(response.body)
         else
           message = response.body.is_a?(String) ? [response.reason_phrase, response.status].join(" ") : response.body[:detail]
           raise KudagoClient::Error.new(message:, status: response.status, reason: response.reason_phrase)
@@ -22,13 +23,6 @@ module KudagoClient
       def self.connection
         @@connection ||= Connection.connection
       end
-
-      def self.parse_response_urls(res)
-        res[:next_url] = res.delete :next
-        res[:previous_url] = res.delete :previous
-
-        res
-      end
     end
   end
 end

data/lib/kudago_client/requests/event_category_request.rb

@@ -9,9 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :fields, :order_by)
-        res = get(PATH, params)
-
-        parse_response_urls({results: res, count: res.size})
+        get(PATH, params)
       end
 
       def self.find(event_category_id, params = {})

data/lib/kudago_client/requests/event_of_the_day_request.rb

@@ -12,11 +12,18 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :text_format, :location, :date)
         res = get(PATH, params)
 
-        res[:results] = res[:results].map do |event_data|
-          parse_event_data(event_data)
-        end
-
-        parse_response_urls(res)
+        # looks bad a little :(
+        results = res.data[:results]
+        res.data[:results] =
+          if results.nil?
+            []
+          else
+            res.data[:results] = res.data[:results].map do |event_data|
+              parse_event_data(event_data)
+            end
+          end
+
+        res
       end
 
       private_class_method

data/lib/kudago_client/requests/event_request.rb

@@ -11,7 +11,7 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :text_format, :ids, :location,
           :actual_since, :actual_until, :place_id, :parent_id, :is_free, :categories, :tags, :lon, :lat, :radius)
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(event_id, params = {})
@@ -21,7 +21,7 @@ module KudagoClient
 
       def self.comments(event_id, params = {})
         params.slice!(:lang, :page, :page_size, :fields, :order_by, :ids)
-        parse_response_urls(get("#{PATH}#{event_id}/comments/", params))
+        get("#{PATH}#{event_id}/comments/", params)
       end
 
       def self.comment(event_id, comment_id, params = {})

data/lib/kudago_client/requests/list_request.rb

@@ -9,7 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :text_format, :ids, :tags, :location)
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(list_id, params = {})
@@ -19,7 +19,7 @@ module KudagoClient
 
       def self.comments(list_id, params = {})
         params.slice!(:lang, :page, :page_size, :fields, :order_by, :ids)
-        parse_response_urls(get("#{PATH}#{list_id}/comments/", params))
+        get("#{PATH}#{list_id}/comments/", params)
       end
 
       def self.comment(list_id, comment_id, params = {})

data/lib/kudago_client/requests/location_request.rb

@@ -9,9 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :fields, :order_by)
-        res = get(PATH, params)
-
-        parse_response_urls({results: res, count: res.size})
+        get(PATH, params)
       end
 
       def self.find(slug, params = {})

data/lib/kudago_client/requests/movie_request.rb

@@ -11,7 +11,7 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :text_format, :ids, :tags,
           :location, :premiering_in_location, :is_free, :place_id, :actual_since, :actual_until)
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(movie_id, params = {})
@@ -23,12 +23,12 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :location,
           :actual_since, :actual_until, :place, :is_free)
 
-        parse_response_urls(get("#{PATH}#{movie_id}/showings/", params))
+        get("#{PATH}#{movie_id}/showings/", params)
       end
 
       def self.comments(movie_id, params = {})
         params.slice!(:lang, :page, :page_size, :fields, :order_by, :ids)
-        parse_response_urls(get("#{PATH}#{movie_id}/comments/", params))
+        get("#{PATH}#{movie_id}/comments/", params)
       end
     end
   end

data/lib/kudago_client/requests/movie_showing_request.rb

@@ -11,7 +11,7 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :ids,
           :location, :actual_since, :actual_until, :place_id, :is_free)
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(showing_id, params = {})

data/lib/kudago_client/requests/news_request.rb

@@ -11,7 +11,7 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :fields, :expand, :order_by, :text_format, :ids, :tags,
           :location, :place_id, :actual_only)
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(news_id, params = {})
@@ -21,7 +21,7 @@ module KudagoClient
 
       def self.comments(news_id, params = {})
         params.slice!(:lang, :page, :page_size, :fields, :order_by, :ids)
-        parse_response_urls(get("#{PATH}#{news_id}/comments/", params))
+        get("#{PATH}#{news_id}/comments/", params)
       end
 
       def self.comment(news_id, comment_id, params = {})

data/lib/kudago_client/requests/place_category_request.rb

@@ -9,9 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :fields, :order_by)
-        res = get(PATH, params)
-
-        parse_response_urls({results: res, count: res.size})
+        get(PATH, params)
       end
 
       def self.find(place_category_id, params = {})

data/lib/kudago_client/requests/place_request.rb

@@ -9,10 +9,9 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :fields, :page, :page_size, :expand, :order_by, :text_format, :ids, :location,
-          :has_showings, :showing_since, :showing_until, :is_free, :categories, :tags, :parent_id,
-          :lon, :lat, :radius)
+          :has_showings, :showing_since, :showing_until, :is_free, :categories, :tags, :parent_id, :lon, :lat, :radius)
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(place_id, params = {})
@@ -22,7 +21,7 @@ module KudagoClient
 
       def self.comments(place_id, params = {})
         params.slice!(:lang, :place_id, :page, :page_size, :fields, :order_by, :ids)
-        parse_response_urls(get("#{PATH}#{place_id}/comments/", params))
+        get("#{PATH}#{place_id}/comments/", params)
       end
     end
   end

data/lib/kudago_client/requests/role_request.rb

@@ -9,7 +9,7 @@ module KudagoClient
 
       def self.list(params = {})
         params.slice!(:lang, :fields)
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
 
       def self.find(agent_id, params = {})

data/lib/kudago_client/requests/search_request.rb

@@ -11,7 +11,7 @@ module KudagoClient
         params.slice!(:lang, :page, :page_size, :expand, :location, :ctype, :is_free, :include_inactual, :lat, :lon, :radius)
         params[:q] = query
 
-        parse_response_urls(get(PATH, params))
+        get(PATH, params)
       end
     end
   end

data/lib/kudago_client/response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash"
+
+module KudagoClient
+  class Response
+    attr_reader :list, :data
+
+    def initialize(response_body)
+      @list = true
+
+      prepared_data =
+        if response_body.is_a? Array
+          data_with_count = parse_with_count(response_body)
+          parse_response_urls(data_with_count)
+        elsif response_body.is_a?(Hash) && response_body.key?(:count)
+          parse_response_urls(response_body)
+        else
+          @list = false
+          response_body
+        end
+
+      @data = prepared_data
+    end
+
+    def list?
+      list
+    end
+
+    private
+
+    def parse_response_urls(res)
+      res[:next_url] = res.delete :next
+      res[:previous_url] = res.delete :previous
+
+      res
+    end
+
+    def parse_with_count(res)
+      {results: res, count: res.size}
+    end
+  end
+end

data/lib/kudago_client/version.rb

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

data/lib/kudago_client.rb

@@ -1,5 +1,4 @@
 require_relative "kudago_client/client"
 
 module KudagoClient
-  VERSION = "0.8.0"
 end

data/to_do.md

@@ -0,0 +1,6 @@
+# To Do and Notes
+
+* EventOfTheDayRequest parse data very bad
+* client work with lang (params or default) very bad too
+* there are no tests :)
+* add a params parser/validator for requests

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kudago-client
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: '1.0'
 platform: ruby
 authors:
 - andrew-kh8
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-23 00:00:00.000000000 Z
+date: 2025-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.16'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: standard
   requirement: !ruby/object:Gem::Requirement
@@ -112,7 +140,10 @@ files:
 - lib/kudago_client/requests/place_request.rb
 - lib/kudago_client/requests/role_request.rb
 - lib/kudago_client/requests/search_request.rb
+- lib/kudago_client/response.rb
+- lib/kudago_client/version.rb
 - sig/kudago_client/client.rbs
+- to_do.md
 homepage: https://github.com/andrew-kh8/kudago-client
 licenses:
 - MIT