pastvu 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ede36b18a77672d8488001474123f2e4a869ee521d2006c8a56186a6f3c9b30
+  data.tar.gz: 6e222696f72e76757ea24a0f8dd7dfc0d089f1b4081665708bc7d531548fda22
+SHA512:
+  metadata.gz: e34ccfa15c79465afa76b9ea236f53675caaa5f7e8e88d6734b7d72fef2a39a49ef5d24c7bc559778c083a13ed1c6490bbbb08b5e8e9cad4b5b5b55fcd84b624
+  data.tar.gz: 26f7aaaa4014f9afb341876fa932354687ab0568c5257bb6bf88b6567d028a627c5a3ca6242780676c78e46fbf088be1dea92bf5e879a5fbc81b46634e154508

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [1.0.0] - 2023-1-12
+
+- First release!
+
+## [0.0.1] - 2023-1
+
+- Unreleased pre-release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 projecteurlumiere
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,301 @@
+# PastVu
+
+PastVu gem is a Ruby wrapper for [PastVu API](https://docs.pastvu.com/en/dev/api). It allows convenient interaction with the API in your Ruby code.
+
+[PastVu](https://pastvu.com) is an open-source online platform for gathering, geo-tagging, attributing and discussing retro photos. Its [repository](https://github.com/PastVu/pastvu) can be found on GitHub.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add pastvu --version "~> 1.0.0"
+
+or add the following line to the Gemfile manually
+
+    # gem "pastvu", "~> 1.0.0"
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install pastvu
+
+and do not forget to require the gem in your code:
+
+```ruby
+require "pastvu"
+```
+
+## Usage
+
+Refer to [PastVu API documentation](https://docs.pastvu.com/en/dev/api) for available interactions, parameters, parameter types and response examples.
+
+### Scenario: Getting nearest photos
+
+#### Step one - request data
+
+```ruby
+golden_gate_coordinates = [37.82,-122.469322]
+
+# It sends photo.giveNearestPhotos request
+# Returns a PhotoCollection instance on success
+photo_collection = Pastvu.nearest_photos(geo: golden_gate_coordinates)
+
+# Optional params, too, go as keyword arguments:
+photo_collection = Pastvu.nearest_photos(
+  geo: golden_gate_coordinates,
+  except: 228481,
+  limit: 12
+)
+
+# PastVu API does not allow requesting >30 nearest photos
+# but you can skip the ones you have already requested
+new_photo_collection = photo_collection.next
+
+# The previous limit (12 in the case above or 30 if no limit was specified) defines how many photos the new collection gets
+# It is possible to set a new limit in the argument (no more than 30!):
+new_photo_collection = photo_collection.next(5)
+```
+
+#### Step two - work with data
+
+##### Manipulate attributes:
+
+```ruby
+# The full response can be immediately transformed into JSON or Hash
+photo_collection.to_json
+photo_collection.to_hash
+
+# On iteration pastvu gem extracts photo information into Photo object
+photo_collection.each do |photo|
+  # Photo attributes are available as methods:
+  puts photo.title
+  puts photo.year
+  puts photo.geo
+  # etc
+
+  # Photo can be transformed into hash:
+  hash = photo.to_hash
+  puts hash["title"]
+  puts hash["year"]
+  puts hash["geo"]
+  # etc
+
+  # and into json:
+  photo.to_json
+end
+```
+
+##### Download photos:
+
+```ruby
+photo_collection.each_with_index do |photo, i|
+  # All return download URL as String:
+  photo.standard
+  photo.original
+  photo.thumb # or thumbnail
+
+  # The path to a new photo must end with ".jpg" or ".jpeg"
+  desired_path_to_photo = "awesome_photo_number_#{i + 1}.jpg"
+
+  # All return File object:
+  photo.download(desired_path_to_photo, :standard)
+  photo.download(desired_path_to_photo, :original)
+  photo.download(desired_path_to_photo, :thumb) # or :thumbnail
+end
+```
+
+##### Request more data about the photo:
+
+```ruby
+photo_collection.each do |photo|
+  # To make a request for comments:
+  photo.comments # returns CommentCollection
+  # See also the section on comments
+
+  # To make a request for full photo information
+  photo.reload # returns a new Photo object
+  # See also the section on photo information
+end
+```
+
+### Scenario: Getting photos inside geographical bounds
+
+#### Step one - prepare request
+
+PastVu API accepts geoJSON polygons and geoJSON multipolygons
+
+```ruby
+# use JSON string in the GeoJSON format:
+paris_montmartre = '{"coordinates":[[[2.34218629483172,48.88623415508624],[2.34218629483172,48.88425956838617],[2.3449771858020085,48.88425956838617],[2.3449771858020085,48.88623415508624],[2.34218629483172,48.88623415508624]]],"type":"Polygon"}'
+
+# or use hash in the GeoJSON format:
+paris_montmartre = {
+  "type" => "Polygon",
+  "coordinates" => [
+    [
+      [
+      2.34218629483172,
+      48.88623415508624
+      ],
+      [
+      2.34218629483172,
+      48.88425956838617
+      ],
+      [
+      2.3449771858020085,
+      48.88425956838617
+      ],
+      [
+      2.3449771858020085,
+      48.88623415508624
+      ],
+      [
+      2.34218629483172,
+      48.88623415508624
+      ]
+    ]
+  ]
+}
+```
+
+#### Step two - request data
+
+```ruby
+# It sends photo.getByBounds request
+# It returns BoundsResponse
+bounds_response = Pastvu.by_bounds(
+  geometry: paris_montmartre,
+  z: 16
+)
+```
+
+The response may contain clusters, photos, or both - see [API docs](https://docs.pastvu.com/en/dev/api)
+
+```ruby
+photo_collection = bounds_response.photos # returns PhotoCollection
+
+cluster_collection = bounds_response.clusters # returns ClusterCollection
+```
+
+#### Step three - manipulate data
+
+##### Photos
+
+PhotoCollection and each photo object have almost all the same methods as discussed in the previous scenario section.
+
+Note that PastVu API may send different photo data for by_bounds and nearest_photos requests. This, however, does not obstruct in-built convenience methods for downloading.
+
+For instance:
+```ruby
+photo_collection.each do |photo|
+  photo.original # will work
+  photo.year2 # should work for by_bounds but might not work for nearest_photos
+end
+
+photo_collection.next # will not work for by_bounds
+```
+
+##### Clusters
+
+On the [Pastvu website](https://pastvu.com), clusters are representations of multiple photos. Users see clusters when zooming out.
+
+```ruby
+# The full response can be immediately transformed into JSON or Hash
+cluster_collection.to_json
+cluster_collection.to_hash
+
+cluster_collection.each do |cluster|
+  # Cluster attributes are available as methods:
+  puts cluster.c
+  # etc
+
+  # Cluster can be transformed into Hash
+  hash = cluster.to_hash
+  puts hash["c"]
+  # etc
+
+  # and into JSON
+  cluster.to_json
+
+  cluster.photo # returns Photo object corresponding to the clusters cover thumbnail
+end
+```
+
+### Scenario: Getting full photo information
+
+```ruby
+  photo_cid = 5
+
+  # It sends photo.giveForPage request
+  # Returns informationResponse on success
+  photo_information = Pastvu.photo_info(photo_cid)
+
+  # informationResponse can be transformed into JSON and Hash
+  photo_information.to_json
+  photo_information.to_hash
+
+  photo = photo_information.to_photo # returns Photo object
+
+  # There is also a shorthand to return Photo object immediately instead of informationResponse
+  photo = Pastvu.photo(photo_cid)
+```
+
+The created Photo object will respond to all the methods discussed previously but it tends to have more attributes. Finally, it is possible to request full information for any Photo object by calling `Photo#reload` on Photo instance, which returns a new Photo instance.
+
+### Scenario: Getting commentaries for a photo
+
+```ruby
+photo_cid = 5
+
+# It makes comment.giveForObj request
+# It returns CommentCollection on success
+comment_collection = Pastvu.comments(photo_cid)
+
+comment_collection.users # returns hash with data about all the users who left a comment under the photo
+
+comment_collection.each do |comment|
+  # Comment attributes are available as methods
+  puts cluster.user
+  puts cluster.txt
+  # etc
+
+  # Cluster can be transformed into Hash
+  hash = cluster.to_hash
+  puts hash["user"]
+  puts hash["txt"]
+  # etc
+
+  # and into JSON
+  cluster.to_json
+
+
+  comment.replies # returns Array containing  replies to the given comment
+end
+```
+
+### Configuration
+
+```ruby
+Pastvu.configure do |c|
+
+  c.host # "pastvu.com"
+  c.path # "api2"
+  c.user_agent # "Ruby PastVu Gem/#{VERSION}, #{RUBY_PLATFORM}, Ruby/#{RUBY_VERSION}"
+
+  # Raise when API response is not of expected format
+  c.ensure_successful_responses # "true"
+
+  # Raise when supplied params are not of the required type
+  c.check_params_type # "true"
+
+  # Raise when supplied params are not of the required values
+  c.check_params_value # "true"
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/projecteurlumiere/pastvu.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/pastvu/basic_response.rb

@@ -0,0 +1,21 @@
+module Pastvu
+  class BasicResponse
+    attr_accessor :json, :hash
+
+    def initialize(response_body)
+      @json = response_body
+      if Pastvu.config.ensure_successful_responses
+        @hash = self.to_hash
+        raise RuntimeError, "Unexpected response from the server: #{@hash}"  unless @hash["result"]
+      end
+    end
+
+    def to_json
+      @hash ? Parser.to_json(@hash) : @json
+    end
+
+    def to_hash
+      @hash || Parser.to_hash(@json)
+    end
+  end
+end

data/lib/pastvu/cluster/cluster.rb

@@ -0,0 +1,7 @@
+module Pastvu
+  class Cluster < Model
+    def photo
+      Photo.new @p
+    end
+  end
+end

data/lib/pastvu/cluster/cluster_collection.rb

@@ -0,0 +1,9 @@
+module Pastvu
+  class ClusterCollection < Collection
+    def initialize(attributes)
+      super attributes
+      @path = %w[result clusters]
+      @model = Cluster
+    end
+  end
+end

data/lib/pastvu/collection.rb

@@ -0,0 +1,27 @@
+module Pastvu
+  class Collection < BasicResponse
+    include Enumerable
+
+    def initialize(attr)
+      attr.instance_of?(Hash) ? @hash = attr : super
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+
+      @hash ||= self.to_hash
+
+      reduce_hash.each do |model_hash|
+        yield @model.new model_hash
+      end
+    end
+
+    private
+
+    def reduce_hash
+      @path.reduce(@hash) do |hash, path_key|
+        hash.fetch(path_key)
+      end
+    end
+  end
+end

data/lib/pastvu/comment/comment.rb

@@ -0,0 +1,29 @@
+module Pastvu
+  class Comment < Model
+    def replies
+      populate_replies unless @comments.nil?
+      @replies ||= []
+    end
+
+    def replies=(value)
+      @replies = value
+    end
+
+    def to_hash
+      instance_variables.each_with_object({}) do |var, object|
+        next if var == :@replies
+
+        var = var[1..-1]
+        object[camelize(var).to_sym] = method(var).call
+      end
+    end
+
+    private
+
+    def populate_replies
+      @replies = @comments.map do |comment|
+        Comment.new comment
+      end
+    end
+  end
+end

data/lib/pastvu/comment/comment_collection.rb

@@ -0,0 +1,18 @@
+module Pastvu
+  class CommentCollection < Collection
+    def initialize(attributes)
+      super attributes
+      @path = %w[result comments]
+      @model = Comment
+    end
+
+    def users
+      @hash ||= self.to_hash
+      @hash["result"]["users"]
+    end
+
+    def photo
+      Pastvu.photo @hash["result"]["cid"]
+    end
+  end
+end

data/lib/pastvu/configuration.rb

@@ -0,0 +1,38 @@
+module Pastvu
+  class Configuration
+    VALID_OPTIONS = %i[
+      host
+      path
+      user_agent
+      ensure_successful_responses
+      check_params_type
+      check_params_value
+    ]
+
+    DEFAULT_VALUES = {
+      default_host: "pastvu.com",
+      default_path: "api2",
+      default_user_agent: "Ruby PastVu Gem/#{VERSION}, #{RUBY_PLATFORM}, Ruby/#{RUBY_VERSION}",
+      default_ensure_successful_responses: true,
+      default_check_params_type: true,
+      default_check_params_value: true
+    }
+
+    attr_accessor *VALID_OPTIONS
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      VALID_OPTIONS.each do |option|
+        self.send(option.to_s.concat("=").to_sym, DEFAULT_VALUES["default_".concat(option.to_s).to_sym])
+      end
+    end
+
+    def configure
+      yield self
+      self
+    end
+  end
+end

data/lib/pastvu/model.rb

@@ -0,0 +1,38 @@
+module Pastvu
+  class Model
+    def initialize(attributes)
+      attributes.each do |key, value|
+        key = snakecase(key)
+        instance_variable_set("@#{key}", value)
+        self.class.send(:attr_accessor, key)
+      end
+    end
+
+    def to_hash
+      instance_variables.each_with_object({}) do |var, object|
+        var = var[1..-1]
+        object[camelize(var).to_sym] = method(var).call
+      end
+    end
+
+    def to_json
+      Parser.to_json(to_hash)
+    end
+
+    private
+
+    def snakecase(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    def camelize(snake_cased_word, capitalize_first_letter = false)
+      array = snake_cased_word.to_s.split('_').collect(&:capitalize)
+      array[0]&.downcase! unless capitalize_first_letter
+      array.join
+    end
+  end
+end

data/lib/pastvu/params_validator/type_check.rb

@@ -0,0 +1,48 @@
+module Pastvu
+  class TypeCheck
+    ALLOWED_TYPES = {
+      cid:        Integer,
+      distance:   Integer, # <= 1000000 (meters)
+      except:     Integer,
+      geo:        Array, # [lat and lon]
+      geometry:   Hash, # [geoJSON]
+      isPainting: [TrueClass, FalseClass],
+      limit:      Integer, # <= 30
+      localWork:  [TrueClass, FalseClass],
+      skip:       Integer,
+      type:       String, # "photo" or "painting"
+      year:       Integer,
+      year2:      Integer,
+      z:          Integer
+    }
+
+    def self.validate(params)
+      errors = {}
+      ALLOWED_TYPES.each do |k, type|
+        param = params[k]
+        next if param.nil?
+        next if self.correct_type? param, type
+
+        errors.merge!({ k.to_sym => [param, type] })
+      end
+
+      errors.empty? ? true : report_errors(errors)
+    end
+
+    def self.report_errors(errors)
+      report = errors.map do |k, v|
+        "\n#{k}: #{v[0]} must be #{v[1]}"
+      end.join(", ")
+
+      raise ArgumentError, "expect correct params type\n #{report}"
+    end
+
+    def self.correct_type?(param, type)
+      if type.instance_of?(Array)
+        type.any? { |type| param.instance_of?(type) }
+      else
+        param.instance_of?(type)
+      end
+    end
+  end
+end

data/lib/pastvu/params_validator/value_check.rb

@@ -0,0 +1,53 @@
+module Pastvu
+  class ValueCheck
+    VALIDATIONS = {
+      distance: ->(d) { d.between?(1, 1_000_000) },
+      geo:     [->(g) { g.size == 2 },
+                ->(g) { g.all? { |coordinate| coordinate.instance_of?(Float) || coordinate.instance_of?(Integer) } }],
+      geometry: ->(g) do
+                  begin
+                    permitted_types  = %w[Polygon Multipolyigon]
+                    permitted_types.any? { |t| t == g["type"] }
+                  rescue TypeError
+                    false
+                  end
+                end,
+      limit:    ->(l) { l.between?(1, 30) },
+      type:     ->(t) { %w[photo painting].any?(t.downcase) }
+    }
+
+    def self.validate(params)
+      errors = {}
+
+      VALIDATIONS.each do |k, v|
+        next if params[k].nil?
+
+        next if v.instance_of?(Array) ? call_each(v, params[k]) : v.call(params[k])
+
+        errors.merge!({ k.to_sym => [params[k], v] })
+      end
+
+      if errors.empty?
+        true
+      else
+        report_errors(errors)
+      end
+    end
+
+    def self.report_errors(errors)
+      report = errors.map do |k, v|
+        "\n#{k}: #{v[0]}"
+      end.join(", ")
+
+      raise ArgumentError, "expect params to pass validations\n #{report}"
+    end
+
+    def self.call_each(array, argument)
+      array.each do |lambda|
+        return false unless lambda.call(argument)
+      end
+
+      true
+    end
+  end
+end

data/lib/pastvu/params_validator.rb

@@ -0,0 +1,8 @@
+module Pastvu
+  class ParamsValidator
+    def self.validate(params)
+      TypeCheck.validate(params) if Pastvu.config.check_params_type
+      ValueCheck.validate(params) if Pastvu.config.check_params_value
+    end
+  end
+end

data/lib/pastvu/parser.rb

@@ -0,0 +1,21 @@
+require "json"
+
+module Pastvu
+  class Parser
+    def self.to_json(hash)
+      JSON.dump(hash)
+    end
+
+    def self.to_hash(json)
+      hash = JSON.parse(json)
+      # symbolize_keys hash
+    end
+
+    # def self.symbolize_keys(hash)
+    #   hash.transform_keys do |k|
+    #     k.to_sym
+    #     symbolize_keys(hash[k]) if hash[k].instance_of?(Hash)
+    #   end
+    # end
+  end
+end

data/lib/pastvu/photo/photo.rb

@@ -0,0 +1,37 @@
+module Pastvu
+  class Photo < Model
+    # VALID_ATTRIBUTES = %w[cid s file title dir geo year ccount]
+    # attr_accessor *VALID_ATTRIBUTES
+
+    def reload
+      Pastvu.photo @cid
+    end
+
+    def comments
+      Pastvu.comments @cid
+    end
+
+    def download(size, path)
+      raise ArgumentError, "expect size to be correct symbol" unless %i[original standard thumbnail thumb].include?(size)
+      raise ArgumentError, "expect file extension to be .jpeg or .jpg" unless path[-4..-1] == ".jpg" || path[-5..-1] == ".jpeg"
+
+      Request.download(method(size).call, path)
+    end
+
+    def standard
+      "https://pastvu.com/_p/d/".concat(file)
+    end
+
+    def original
+      "https://pastvu.com/_p/a/".concat(file)
+    end
+
+    def thumbnail
+      "https://pastvu.com/_p/h/".concat(file)
+    end
+
+    def thumb
+      thumbnail
+    end
+  end
+end

data/lib/pastvu/photo/photo_collection.rb

@@ -0,0 +1,26 @@
+module Pastvu
+  class PhotoCollection < Collection
+    def initialize(attributes, params = nil)
+      super attributes
+      @params = params
+      @path = %w[result photos]
+      @model = Photo
+    end
+
+    def next(n_photos = nil)
+      raise "next can be used with nearest photos requests only" if @params.nil?
+
+      n_photos ||= @params[:limit] || 30
+      # params get passed to PhotoCollection when it is a request for nearest photos on.y
+      raise ArgumentError, "n_photos must be Integer between 1 & 30" unless n_photos.instance_of?(Integer) && n_photos.between?(1, 30)
+
+      new_skip = {
+        skip: (@params[:skip] || 0) + n_photos
+      }
+
+      new_params = @params.merge(new_skip)
+
+      Pastvu.nearest_photos(geo: @params[:geo], **new_params)
+    end
+  end
+end

data/lib/pastvu/request.rb

@@ -0,0 +1,42 @@
+require "net/http"
+require "addressable"
+require "open-uri"
+
+module Pastvu
+  class Request
+    attr_reader :response
+
+    def initialize(method, params)
+      @method = method
+      @params = params
+
+      request(build_uri)
+    end
+
+    def self.download(uri, path)
+      download = URI.parse(uri).open("User-Agent" => Pastvu.config.user_agent)
+      IO.copy_stream(download, path)
+      File.new(path)
+    end
+
+    def request(uri)
+      Net::HTTP.get_response(uri, "User-Agent" => Pastvu.config.user_agent) do |response|
+        @response = response.body
+      end
+    end
+
+    def build_uri
+      uri = Addressable::URI.new({ scheme: 'https', host: Pastvu.config.host })
+
+      template = Addressable::Template.new(uri.to_s + "{/path*}" + "{?query*}")
+
+      template.expand({
+        "path" => Pastvu.config.path,
+        "query" => {
+          "method" => @method,
+          "params" => JSON.dump(@params)
+        }
+      })
+    end
+  end
+end

data/lib/pastvu/response/bounds_response.rb

@@ -0,0 +1,13 @@
+module Pastvu
+  class BoundsResponse < BasicResponse
+    def clusters
+      @hash ||= self.to_hash
+      ClusterCollection.new @hash
+    end
+
+    def photos
+      @hash ||= self.to_hash
+      PhotoCollection.new @hash
+    end
+  end
+end

data/lib/pastvu/response/information_response.rb

@@ -0,0 +1,8 @@
+module Pastvu
+  class InformationResponse < BasicResponse
+    def to_photo
+      @hash ||= self.to_hash
+      Photo.new @hash["result"]["photo"]
+    end
+  end
+end

data/lib/pastvu/version.rb

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

data/lib/pastvu.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "pastvu/version"
+require_relative "pastvu/configuration"
+require_relative "pastvu/request"
+require_relative "pastvu/basic_response"
+require_relative "pastvu/model"
+require_relative "pastvu/collection"
+require_relative "pastvu/parser"
+require_relative "pastvu/params_validator"
+
+require_relative "pastvu/response/bounds_response"
+require_relative "pastvu/response/information_response"
+require_relative "pastvu/cluster/cluster_collection"
+require_relative "pastvu/cluster/cluster"
+require_relative "pastvu/comment/comment_collection"
+require_relative "pastvu/comment/comment"
+require_relative "pastvu/photo/photo_collection"
+require_relative "pastvu/photo/photo"
+
+require_relative "pastvu/params_validator/type_check"
+require_relative "pastvu/params_validator/value_check"
+
+module Pastvu
+  METHODS = {
+    photo_info:     "photo.giveForPage",
+    comments:       "comment.giveForObj",
+    nearest_photos: "photo.giveNearestPhotos",
+    by_bounds:      "photo.getByBounds"
+  }
+
+  def self.photo_info(cid)
+    params = {
+      cid: cid
+    }
+
+    ParamsValidator.validate params
+
+    InformationResponse.new request(__method__, params)
+  end
+
+  def self.photo(cid)
+    self.photo_info(cid).to_photo
+  end
+
+  def self.comments(cid)
+    params = {
+      cid: cid
+    }
+
+    ParamsValidator.validate params
+
+    CommentCollection.new request(__method__, params)
+  end
+
+  def self.nearest_photos(geo:, **params)
+    params = {
+      geo:      geo,
+      except:   params[:except],
+      distance: params[:distance],
+      year:     params[:year],
+      year2:    params[:year2],
+      type:     params[:type],
+      limit:    params[:limit],
+      skip:     params[:skip]
+    }.compact
+
+    ParamsValidator.validate params
+
+    PhotoCollection.new request(__method__, params), params
+  end
+
+  def self.by_bounds(geometry:, z:, **params)
+    params[:localWork] = true if z >= 17
+
+    params = {
+      geometry:   geometry.instance_of?(Hash) ? geometry : Parser.to_hash(geometry),
+      z:          z,
+      isPainting: params[:isPainting] || params[:is_painting],
+      year:       params[:year],
+      year2:      params[:year2],
+      localWork:  params[:localWork] || params[:local_work]
+    }.compact
+
+    ParamsValidator.validate params
+
+    BoundsResponse.new request(__method__, params)
+  end
+
+  def self.request(method, params)
+    Request.new(METHODS[method], params).response
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure(&block)
+    config.configure(&block)
+  end
+end

data/pastvu.gemspec

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "lib/pastvu/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pastvu"
+  spec.version = Pastvu::VERSION
+  spec.authors = ["Evgeny Nedoborskiy"]
+  spec.email = ["129510705+projecteurlumiere@users.noreply.github.com"]
+  spec.homepage = "https://github.com/projecteurlumiere/pastvu"
+  spec.summary = "A Ruby wrapper for PastVu API"
+
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .rspec .circleci appveyor Gemfile])
+    end
+  end
+
+  spec.add_dependency "addressable", "~> 2.8"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.19"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: pastvu
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Evgeny Nedoborskiy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !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: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+description: 
+email:
+- 129510705+projecteurlumiere@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/pastvu.rb
+- lib/pastvu/basic_response.rb
+- lib/pastvu/cluster/cluster.rb
+- lib/pastvu/cluster/cluster_collection.rb
+- lib/pastvu/collection.rb
+- lib/pastvu/comment/comment.rb
+- lib/pastvu/comment/comment_collection.rb
+- lib/pastvu/configuration.rb
+- lib/pastvu/model.rb
+- lib/pastvu/params_validator.rb
+- lib/pastvu/params_validator/type_check.rb
+- lib/pastvu/params_validator/value_check.rb
+- lib/pastvu/parser.rb
+- lib/pastvu/photo/photo.rb
+- lib/pastvu/photo/photo_collection.rb
+- lib/pastvu/request.rb
+- lib/pastvu/response/bounds_response.rb
+- lib/pastvu/response/information_response.rb
+- lib/pastvu/version.rb
+- pastvu.gemspec
+homepage: https://github.com/projecteurlumiere/pastvu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key: 
+specification_version: 4
+summary: A Ruby wrapper for PastVu API
+test_files: []