yandex_client 0.1.0 → 1.0.1

data/.travis.yml

@@ -1,12 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.6.3
-before_install: gem install bundler
-before_script:
-  - bundle install
-script: bundle exec rspec
-notifications:
-  email:
-    on_success: never
-    on_failure: always

data/docker/Dockerfile.2.6

@@ -1,9 +0,0 @@
-FROM ruby:2.6.3
-
-RUN ln -fs /usr/share/zoneinfo/Asia/Yekaterinburg /etc/localtime \
-  && dpkg-reconfigure -f noninteractive tzdata
-
-RUN echo 'gem: --no-rdoc --no-ri --no-document' > /root/.gemrc
-RUN gem install bundler
-
-WORKDIR /app

data/docker/docker-compose.development.yml

@@ -1,18 +0,0 @@
-version: '2'
-
-services:
-  app:
-    volumes:
-      - ..:/app
-      - ../:/localgems
-      - ssh-data:/ssh:ro
-      - bundler-data:/bundle
-
-volumes:
-  bundler-data:
-    external:
-      name: bundler_data
-
-  ssh-data:
-    external:
-      name: ssh_data

data/lib/yandex_client/api_request_error.rb

@@ -1,13 +0,0 @@
-module YandexClient
-  class ApiRequestError < StandardError
-    attr_reader :error, :error_description, :code
-
-    def initialize(error:, error_description:, code:)
-      @error = error
-      @error_description = error_description
-      @code = code
-
-      super [error, error_description, "http code #{@code}"].compact.join(', ')
-    end
-  end
-end

data/lib/yandex_client/auth/client.rb

@@ -1,55 +0,0 @@
-require 'uri'
-
-module YandexClient
-  module Auth
-    # https://tech.yandex.ru/oauth/doc/dg/reference/refresh-client-docpage/
-    # https://tech.yandex.ru/oauth/doc/dg/reference/auto-code-client-docpage/#auto-code-client__get-token
-    #
-    # https://oauth.yandex.ru/authorize?response_type=code&client_id=99bcbd17ad7f411694710592d978a4a2&force_confirm=false
-    #
-    # Example:
-    #   token = Token.first
-    #
-    #   client = YandexClient::Auth::Client.new
-    #   client.create_token(code: '9388894')
-    #   client.refresh_token(refresh_token: token.refresh_token)
-    class Client < ::YandexClient::Client
-      AUTH_ACTION_URL = 'https://oauth.yandex.ru/token'.freeze
-
-      ACTIONS = {
-        create_token: 'authorization_code',
-        refresh_token: 'refresh_token'
-      }.freeze
-
-      private
-
-      def http(_request_uri)
-        @http ||= super
-      end
-
-      def http_method_for_action
-        METHOD_POST
-      end
-
-      def request_body(params)
-        body_hash = {
-          grant_type: ACTIONS.fetch(@action),
-          client_id: ::YandexClient.config.api_key,
-          client_secret: ::YandexClient.config.api_secret
-        }.merge!(params)
-
-        URI.encode_www_form(body_hash)
-      end
-
-      def request_headers(_params)
-        {
-          'Content-type' => 'application/x-www-form-urlencoded'
-        }
-      end
-
-      def request_uri(_params)
-        @request_uri ||= URI.parse(AUTH_ACTION_URL)
-      end
-    end
-  end
-end

data/lib/yandex_client/client.rb

@@ -1,97 +0,0 @@
-require 'oj'
-require 'net/http'
-
-module YandexClient
-  # Base api client
-  class Client
-    TIMEOUT = 10
-    METHOD_GET = 'Get'.freeze
-    METHOD_POST = 'Post'.freeze
-
-    ERRORS_BY_CODES = {
-      404 => NotFoundError
-    }.freeze
-
-    def method_missing(method_name, *args, &_)
-      return super unless self.class::ACTIONS.include?(method_name)
-
-      @action = method_name
-      result = nil
-      response = make_request(args.last.is_a?(Hash) ? args.last : {})
-
-      result = parse_response_body(response) unless response.body.nil? || response.body.empty?
-      process_errors(response, result) unless response.is_a?(Net::HTTPSuccess)
-
-      result
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      self.class::ACTIONS.include?(method_name) || super
-    end
-
-    private
-
-    def http(request_uri)
-      Net::HTTP.new(request_uri.host, request_uri.port).tap do |http|
-        http.use_ssl = true
-        http.read_timeout = TIMEOUT
-        http.continue_timeout = TIMEOUT
-      end
-    end
-
-    def http_method_for_action
-      METHOD_GET
-    end
-
-    def log_api_request(request_uri, request, response)
-      return if (logger = YandexClient.config.logger).nil?
-
-      logger.info "#{request.method} #{request_uri} #{response.code} #{response.message}"
-      logger.info "request headers: #{Oj.dump(request.to_hash)}"
-      logger.info "response headers: #{Oj.dump(response.to_hash)}"
-    end
-
-    def make_request(params)
-      request_uri = request_uri(params)
-      @body = request_body(params)
-
-      request = Object.const_get("Net::HTTP::#{http_method_for_action}").new(
-        request_uri.request_uri,
-        request_headers(params)
-      )
-
-      request.body = @body
-      response = http(request_uri).start { |http| http.request(request) }
-
-      log_api_request(request_uri, request, response)
-
-      response
-    end
-
-    def parse_response_body(response)
-      Oj.load(response.body, symbol_keys: true)
-    end
-
-    def process_errors(response, result)
-      klass = ERRORS_BY_CODES.fetch(response.code.to_i, ApiRequestError)
-
-      raise klass.new(
-        error: result.is_a?(Hash) ? result&.fetch(:error) : result,
-        error_description: result.is_a?(Hash) ? result&.fetch(:error_description) : nil,
-        code: response.code.to_i
-      )
-    end
-
-    def request_body(_params)
-
-    end
-
-    def request_headers(_params)
-      {}
-    end
-
-    def request_uri(_params)
-      raise 'not implemented'
-    end
-  end
-end

data/lib/yandex_client/dav/client.rb

@@ -1,115 +0,0 @@
-require 'digest'
-
-module YandexClient
-  module Dav
-    # https://tech.yandex.ru/disk/doc/dg/reference/put-docpage/
-    #
-    # cli = YandexClient::Dav::Client.new(access_token: access_token)
-    #
-    # cli.put(file: '1.txt', name: '/a/b/c/1.txt')
-    # cli.delete(name: '/a/b/c/1.txt')
-    # cli.mkcol(name: '/a/b/c')
-    #
-    # cli.propfind(name: '/a/dip.yml', depth: 0)
-    # cli.propfind(name: '/a', depth: 1)
-    # cli.propfind(name: '/', quota: true)
-    class Client < ::YandexClient::Client
-      ACTION_URL = 'https://webdav.yandex.ru'.freeze
-      PROPFIND_QUERY = '<?xml version="1.0" encoding="utf-8"?><propfind xmlns="DAV:"></propfind>'.freeze
-      PROPFIND_QUOTA_QUERY = <<~XML.freeze
-        <D:propfind xmlns:D="DAV:">
-          <D:prop>
-            <D:quota-available-bytes/>
-            <D:quota-used-bytes/>
-          </D:prop>
-        </D:propfind>
-      XML
-
-      # actions with header processors
-      ACTIONS = {
-        mkcol: nil,
-        delete: nil,
-
-        put: lambda do |params|
-          filename = params.fetch(:file)
-
-          etag = params[:etag] || Digest::MD5.file(filename)
-          sha256 = params[:sha256] || Digest::SHA256.file(filename)
-          size = params[:size] || File.size(filename)
-
-          {
-            Etag: etag.to_s,
-            Sha256: sha256.to_s,
-            Expect: '100-continue',
-            'Content-Length' => size.to_s
-          }
-        end,
-
-        propfind: lambda do |params|
-          depth = 0
-          depth = params.fetch(:depth, 0) unless params.key?(:quota)
-
-          headers = {
-            Depth: depth.to_s,
-            'Content-Type' => 'application/x-www-form-urlencoded'
-          }
-
-          headers['Content-Length'] = @body.length unless @body.nil? || @body.empty?
-          headers
-        end
-      }.freeze
-
-      BODY_PROCESSORS = {
-        put: ->(params) { File.read(params.fetch(:file)) },
-        propfind: lambda do |params|
-          if params.fetch(:quota, false)
-            PROPFIND_QUOTA_QUERY
-          elsif params.fetch(:depth, 0).zero?
-            PROPFIND_QUERY
-          end
-        end
-      }.freeze
-
-      RESPONSE_PARSERS = {
-        propfind: PropfindParser
-      }.freeze
-
-      def initialize(access_token:)
-        @access_token = access_token
-      end
-
-      private
-
-      def http_method_for_action
-        @action.to_s.capitalize
-      end
-
-      def parse_response_body(response)
-        if response.is_a?(Net::HTTPSuccess) && !(parser = RESPONSE_PARSERS[@action]).nil?
-          parser.call(response.body)
-        else
-          response.body
-        end
-      end
-
-      def request_body(params)
-        return if (proc = BODY_PROCESSORS[@action]).nil?
-
-        proc.call(params)
-      end
-
-      def request_headers(params)
-        proc = ACTIONS.fetch(@action)
-
-        headers = {Authorization: "OAuth #{@access_token}"}
-        headers.merge!(proc.call(params)) unless proc.nil?
-
-        headers
-      end
-
-      def request_uri(params)
-        URI.parse("#{ACTION_URL}#{params.fetch(:name)}")
-      end
-    end
-  end
-end

data/lib/yandex_client/dav/propfind_parser.rb

@@ -1,48 +0,0 @@
-require 'ox'
-require 'cgi'
-
-module YandexClient
-  module Dav
-    class PropfindParser
-      SUCCESS_STATUS = 'HTTP/1.1 200 OK'.freeze
-
-      PROCESSORS = {
-        getcontentlength: ->(value) { value.to_i },
-        resourcetype: ->(value) { value.is_a?(Hash) ? :folder : :file }
-      }.freeze
-
-      class ParseError < StandardError
-      end
-
-      def initialize(xml)
-        @document = Ox.load(xml.force_encoding('UTF-8'), mode: :hash)
-      end
-
-      def call
-        @document[:'d:multistatus'].each_with_object({}) do |node, memo|
-          next if (response = node[:'d:response']).nil?
-
-          name = CGI.unescape(response.fetch(:'d:href'))
-          memo[name] = parse_node_props(response.fetch(:'d:propstat'))
-        end
-      end
-
-      def self.call(xml)
-        new(xml).call
-      end
-
-      private
-
-      def parse_node_props(node)
-        raise ParseError unless node.fetch(:'d:status') == SUCCESS_STATUS
-
-        node.fetch(:'d:prop').each_with_object({}) do |(key, value), memo|
-          prop_key = key.to_s.gsub(/^d:/, '').to_sym
-          processor = PROCESSORS[prop_key]
-
-          memo[prop_key] = processor.nil? ? value : processor.call(value)
-        end
-      end
-    end
-  end
-end

data/lib/yandex_client/not_found_error.rb

@@ -1,4 +0,0 @@
-module YandexClient
-  class NotFoundError < ApiRequestError
-  end
-end

data/lib/yandex_client/passport/client.rb

@@ -1,34 +0,0 @@
-module YandexClient
-  module Passport
-    # https://tech.yandex.ru/passport/doc/dg/reference/request-docpage/
-    #
-    # Example:
-    #   client = YandexClient::Passport::Client.new(access_token: Token.first.access_token)
-    #   client.info
-    class Client < ::YandexClient::Client
-      ACTION_URL = 'https://login.yandex.ru/info'.freeze
-      ACTIONS = %i[info].freeze
-
-      # action - info
-      def initialize(access_token:)
-        @access_token = access_token
-      end
-
-      private
-
-      def http(_request_uri)
-        @http ||= super
-      end
-
-      def request_uri(_params)
-        @request_uri ||= URI.parse(ACTION_URL)
-      end
-
-      def request_headers(_params)
-        {
-          Authorization: "Bearer #{@access_token}"
-        }
-      end
-    end
-  end
-end