gemfather-stable 2.2.2

data/gem_template/lib/%app_short_name%/railtie.rb.tt

@@ -0,0 +1,5 @@
+module <%= app_short_name_class %>
+  class Railtie < Rails::Railtie
+    extend ApiGenerator::Railtie
+  end
+end

data/gem_template/lib/%app_short_name%/version.rb.tt

@@ -0,0 +1,5 @@
+module <%= app_short_name_class %>
+  module Version
+    VERSION = '0.0.1'.freeze
+  end
+end

data/gem_template/spec/spec_helper.rb.tt

@@ -0,0 +1,35 @@
+require 'bundler/setup'
+require '<%= app_name %>'
+require 'dotenv/load'
+require 'vcr'
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+
+  config.hook_into :faraday
+
+  config.before_record do |vcr|
+    vcr.response.body.force_encoding('UTF-8')
+  end
+
+  config.configure_rspec_metadata!
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.before do
+    <%= app_name_class %>::Client.configure do |configuration|
+      configuration.api_endpoint = 'http://<%= app_name %>.dev'
+      configuration.api_header = 'X-Source-Token'
+      configuration.api_token = 'TEST_TOKEN'
+      configuration.logger = Logger.new(Pathname.new(__dir__).join('..', 'log', 'test.log'))
+    end
+  end
+end

data/lib/api_generator/client/config.rb

@@ -0,0 +1,57 @@
+module ApiGenerator
+  module Client
+    module Config
+      class ConfigurationError < StandardError; end
+
+      USER_AGENT = 'Ruby API Client'.freeze
+      OPEN_TIMEOUT = 3
+      READ_TIMEOUT = 3
+      MAX_RETRIES = 3
+      RETRY_INTERVAL = 1
+      RETRY_BACKOFF_FACTOR = 1
+      CONNECTION_ERROR = ApiGenerator::Middleware::HttpErrors::ConnectionError
+
+      # rubocop:disable Metrics/MethodLength
+      def self.extended(klass)
+        klass.extend Dry::Configurable
+
+        klass.class_eval do
+          setting :api_endpoint, reader: true
+          setting :user_agent, default: USER_AGENT, reader: true
+
+          setting :api_header, reader: true
+          setting :api_token, reader: true
+
+          setting :api_user, reader: true
+          setting :api_password, reader: true
+
+          setting :ssl_verify, reader: true
+          setting :ca_file, reader: true
+
+          setting :open_timeout, default: OPEN_TIMEOUT, reader: true
+          setting :read_timeout, default: READ_TIMEOUT, reader: true
+          setting :max_retries, default: MAX_RETRIES, reader: true
+          setting :retry_interval, default: RETRY_INTERVAL, reader: true
+          setting :retry_backoff_factor, default: RETRY_BACKOFF_FACTOR, reader: true
+          setting :logger, reader: true
+
+          setting :retriable_errors, default: [CONNECTION_ERROR], reader: true
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def check_config
+        raise ConfigurationError, 'API endpoint is not configured.' if config.api_endpoint.nil?
+      end
+
+      def inherit_config!(other_config)
+        config.to_h.each_key { |setting| config[setting] = other_config[setting] }
+        config
+      end
+
+      def same_config?(other_config)
+        config.to_h == other_config.to_h
+      end
+    end
+  end
+end

data/lib/api_generator/client/connection.rb

@@ -0,0 +1,149 @@
+module ApiGenerator
+  module Client
+    # rubocop:disable Metrics/ClassLength
+    class Connection < SimpleDelegator
+      extend Config
+
+      class << self
+        def inherited(subclass)
+          subclass.extend Middleware::RaiseErrorDsl
+
+          error_namespace = begin
+            subclass.module_parent::HttpErrors
+          rescue NameError
+            ApiGenerator::Middleware::HttpErrors
+          end
+
+          subclass.setup_middleware(error_namespace)
+
+          super
+        end
+
+        def setup_middleware(error_namespace)
+          unsuccessful_request_middleware = Class.new(
+            Middleware::HandleUnsuccessfulRequestMiddleware,
+          )
+          unsuccessful_request_middleware.error_namespace = error_namespace if error_namespace
+          const_set(:HandleUnsuccessfulRequestMiddleware, unsuccessful_request_middleware)
+
+          error_handler_middleware = Class.new(Middleware::ErrorHandlerMiddleware)
+          error_handler_middleware.error_namespace = error_namespace if error_namespace
+          const_set(:ErrorHandlerMiddleware, error_handler_middleware)
+        end
+      end
+
+      ACCEPT_HEADER = 'application/json'.freeze
+
+      attr_accessor :customization_block
+
+      def initialize(**settings, &blk)
+        if instance_of?(Connection)
+          raise LoadError, 'This class is abstract and is not intended to be initialized directly'
+        end
+
+        self.customization_block = blk if blk
+
+        config = self.class.inherit_config!(self.class.config)
+        settings.each { |setting, value| config[setting] = value }
+        self.class.check_config
+
+        super(connection)
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def connection
+        @connection ||= Faraday.new(url: self.class.api_endpoint) do |connection|
+          setup_auth!(connection)
+
+          setup_failed_req_handling!(connection)
+          setup_timeouts!(connection)
+          setup_user_agent!(connection)
+          setup_logger!(connection)
+          setup_retries!(connection)
+          setup_error_handling!(connection)
+          setup_error_code_middleware!(connection)
+          setup_ssl(connection)
+
+          customize_connection!(connection)
+
+          # When set last - req/res parsed as json in middleware
+          setup_json!(connection)
+
+          connection.adapter(Faraday.default_adapter)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/AbcSize
+      def setup_auth!(connection)
+        if self.class.api_token && self.class.api_header
+          connection.headers[self.class.api_header] = self.class.api_token
+        elsif self.class.api_user && self.class.api_password
+          connection.use(
+            Faraday::Request::BasicAuthentication,
+            self.class.api_user,
+            self.class.api_password,
+          )
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def setup_json!(connection)
+        connection.headers[:accept] = ACCEPT_HEADER
+        connection.request(:json)
+        connection.response(:json)
+      end
+
+      def setup_timeouts!(connection)
+        connection.options.open_timeout = self.class.open_timeout
+        connection.options.timeout = self.class.read_timeout
+      end
+
+      def setup_user_agent!(connection)
+        connection.headers[:user_agent] = self.class.user_agent
+      end
+
+      def setup_logger!(connection)
+        connection.response(:logger, self.class.logger) if self.class.logger
+      end
+
+      def setup_ssl(connection)
+        connection.ssl.verify = self.class.ssl_verify
+        connection.ssl.ca_file = self.class.ca_file
+      end
+
+      def setup_retries!(connection)
+        return if self.class.max_retries <= 0
+
+        connection.request(
+          :retry,
+          max: self.class.max_retries,
+          interval: self.class.retry_interval,
+          backoff_factor: self.class.retry_backoff_factor,
+          exceptions: self.class.retriable_errors,
+        )
+      end
+
+      def setup_failed_req_handling!(connection)
+        connection.use(self.class::HandleUnsuccessfulRequestMiddleware)
+      end
+
+      def setup_error_handling!(connection)
+        connection.use(self.class::ErrorHandlerMiddleware)
+      end
+
+      def setup_error_code_middleware!(connection)
+        connection.use(self.class::ErrorCodeMiddleware)
+      end
+
+      def customize_connection!(connection)
+        return unless customization_block
+
+        customization_block.call(connection)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/api_generator/commands/generate.rb

@@ -0,0 +1,56 @@
+module ApiGenerator
+  module Commands
+    class Generate
+      # rubocop:disable Layout/LineLength
+      ARGS_REGEX = /(?<namespace>[\w\-_]+):(?<action>[\w\-_]+):(?<http_method>get|post|patch|put)/i.freeze
+      # rubocop:enable Layout/LineLength
+
+      def initialize(argv)
+        @argv = argv[0..1]
+      end
+
+      def call
+        service_args = [*parse_parameters(@argv), paginate(@argv)]
+
+        shutdown unless service_args[0..2].all?(&:present?)
+
+        Services::CreateScaffold.new(*service_args).call
+      end
+
+      private
+
+      def usage
+        <<~USAGE
+          Generate API scaffold (api_namespace, models, specs)
+          Usage: bin/generate NAMESPACE:ACTION:HTTP_METHOD [--paginate]
+          Examples:
+            bin/generate deals:search:post --paginate
+            bin/generate persons:create:post
+            bin/generate deals:update:put
+        USAGE
+      end
+
+      def shutdown
+        puts(usage) || exit
+      end
+
+      def parse_parameters(args)
+        params = args.find { |arg| arg =~ ARGS_REGEX }
+
+        shutdown unless params
+
+        match_data = params.match(ARGS_REGEX)
+
+        [
+          match_data['namespace'],
+          match_data['action'],
+          match_data['http_method'],
+        ]
+      end
+
+      def paginate(args)
+        args.find { |arg| arg == '--paginate' }
+      end
+    end
+  end
+end

data/lib/api_generator/helpers/utils.rb

@@ -0,0 +1,56 @@
+module ApiGenerator
+  module Helpers
+    module Utils
+      INDENTATION_REGEX = /^([ \t]*)(?=\S)/.freeze
+      WRITE_MODE = 'w'.freeze
+
+      def create_dir(dir)
+        FileUtils.mkdir_p(dir) && log(dir)
+      end
+
+      def log(path)
+        path.gsub!(root, '.') if path.match?(Regexp.new(root))
+        shell.say_status('create', path, :green)
+      end
+
+      def shell
+        Thor::Shell::Color.new
+      end
+
+      def copy_template(template, destination, data_binding)
+        content = render(template, data_binding)
+        destination.gsub!(/\.erb$/, '.rb')
+
+        File.write(destination, content, mode: WRITE_MODE) && log(destination)
+      end
+
+      def render(path, data_binding)
+        ERB.new(File.read(path)).result(data_binding)
+      end
+
+      def inject_after_str(file, str, insert)
+        text = File.read(file)
+        result = inject_after(text, str, insert)
+        File.write(file, result, mode: WRITE_MODE)
+      end
+
+      def inject_after(text, str, insert)
+        lines = text.each_line.to_a
+        regex = Regexp.new(str)
+        match_line_idx = lines.index { |line| line =~ regex }
+
+        return unless match_line_idx
+
+        line = lines[match_line_idx]
+        indented_insert = insert.each_line.map { |insert_line| indent_as(line, insert_line) }
+        lines.insert(match_line_idx + 1, *indented_insert)
+        lines.map(&:chomp).join("\n")
+      end
+
+      def indent_as(source, target)
+        indentation = INDENTATION_REGEX.match(source).captures.first.to_s
+        indentation + target
+      end
+    end
+  end
+end

data/lib/api_generator/middleware/error_code_middleware.rb

@@ -0,0 +1,43 @@
+module ApiGenerator
+  module Middleware
+    class ErrorCodeMiddleware < Faraday::Response::Middleware
+      def self.inherited(subclass)
+        class << subclass
+          attr_accessor :error_mapping, :error_namespace
+
+          def add_error(code, exception)
+            error_mapping[code] = exception
+          end
+        end
+
+        subclass.error_mapping ||= {}
+        subclass.error_namespace ||= ApiGenerator::Middleware::HttpErrors
+
+        super
+      end
+
+      def on_complete(env)
+        error_class = error_class(env.status)
+        return unless error_class
+
+        raise(error_class.new(message(env), env.body))
+      end
+
+      private
+
+      def message(env)
+        "Server returned #{env.status}: #{env.body}. Headers: #{env.response_headers.inspect}"
+      end
+
+      def error_class(code)
+        self.class.error_mapping.fetch(code) do
+          if code >= 500
+            self.class.error_namespace::ServerError
+          elsif code >= 400
+            self.class.error_namespace::ClientError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_generator/middleware/error_handler_middleware.rb

@@ -0,0 +1,26 @@
+module ApiGenerator
+  module Middleware
+    class ErrorHandlerMiddleware < Faraday::Middleware
+      def self.inherited(subclass)
+        class << subclass
+          attr_accessor :error_namespace
+        end
+
+        subclass.error_namespace ||= ApiGenerator::Middleware::HttpErrors
+        super
+      end
+
+      FARADAY_CONNECTION_ERRORS = [
+        Faraday::TimeoutError,
+        Faraday::ConnectionFailed,
+        Faraday::SSLError,
+      ].freeze
+
+      def call(env)
+        @app.call(env)
+      rescue *FARADAY_CONNECTION_ERRORS => e
+        raise self.class.error_namespace::ConnectionError, e
+      end
+    end
+  end
+end

data/lib/api_generator/middleware/handle_unsuccessful_request_middleware.rb

@@ -0,0 +1,36 @@
+module ApiGenerator
+  module Middleware
+    class HandleUnsuccessfulRequestMiddleware < Faraday::Response::Middleware
+      def self.inherited(subclass)
+        class << subclass
+          attr_accessor :error_namespace
+        end
+
+        subclass.error_namespace ||= ApiGenerator::Middleware::HttpErrors
+        super
+      end
+
+      def on_complete(env)
+        response_body = env.body
+
+        return unless response_body.is_a?(Hash) && response_body['success'] == false
+
+        raise(
+          self.class.error_namespace::UnsuccessfulRequestError.new(
+            message(env), env.body,
+          ),
+        )
+      end
+
+      private
+
+      def message(env)
+        <<~MSG
+          Server is unable to process the request: #{env.request_body}.
+          Headers: #{env.request_headers.inspect}
+          Server returned: #{env.body}. Headers: #{env.response_headers.inspect}
+        MSG
+      end
+    end
+  end
+end

data/lib/api_generator/middleware/http_errors.rb

@@ -0,0 +1,21 @@
+module ApiGenerator
+  module Middleware
+    module HttpErrors
+      class ConnectionError < StandardError; end
+
+      class BaseError < StandardError
+        attr_reader :body
+
+        def initialize(msg = nil, body = nil)
+          @body = body if body
+          super(msg)
+        end
+      end
+
+      class ServerError < BaseError; end
+      class ClientError < BaseError; end
+
+      class UnsuccessfulRequestError < ClientError; end
+    end
+  end
+end

data/lib/api_generator/middleware/raise_error_base.rb

@@ -0,0 +1,11 @@
+module ApiGenerator
+  module Middleware
+    class RaiseErrorBase < Faraday::Response::Middleware
+      private
+
+      def message(env)
+        "Server returned #{env.status}: #{env.body}. Headers: #{env.response_headers.inspect}"
+      end
+    end
+  end
+end

data/lib/api_generator/middleware/raise_error_dsl.rb

@@ -0,0 +1,36 @@
+module ApiGenerator
+  module Middleware
+    module RaiseErrorDsl
+      def self.extended(klass)
+        klass.singleton_class.class_eval { attr_accessor :error_namespace }
+        klass.error_namespace ||= if klass.module_parent.const_defined?(:HttpErrors)
+                                    klass.module_parent::HttpErrors
+                                  else
+                                    ApiGenerator::Middleware::HttpErrors
+                                  end
+        error_code_middleware = Class.new(ErrorCodeMiddleware)
+        error_code_middleware.error_namespace = klass.error_namespace
+        klass.const_set(:ErrorCodeMiddleware, error_code_middleware)
+
+        super
+      end
+
+      def on_status(code, error:)
+        self::ErrorCodeMiddleware.add_error(code, error_const(code, error))
+      end
+
+      private
+
+      def error_const(code, error_name)
+        const_name = error_name.to_s.camelize
+
+        return error_namespace.const_get(const_name) if error_namespace.const_defined?(const_name)
+
+        error_namespace.const_set(
+          const_name,
+          Class.new(code >= 500 ? error_namespace::ServerError : error_namespace::ClientError),
+        )
+      end
+    end
+  end
+end

data/lib/api_generator/middleware.rb

@@ -0,0 +1,4 @@
+module ApiGenerator
+  module Middleware
+  end
+end

data/lib/api_generator/models/base.rb

@@ -0,0 +1,15 @@
+module ApiGenerator
+  module Models
+    class Base < Hashie::Trash
+      include Hashie::Extensions::Dash::Coercion
+      include Hashie::Extensions::Dash::IndifferentAccess
+      include Hashie::Extensions::IgnoreUndeclared
+
+      def self.parse_time
+        ->(time) { Time.parse(time) if time.present? }
+      end
+
+      private_class_method :parse_time
+    end
+  end
+end

data/lib/api_generator/models/data.rb

@@ -0,0 +1,16 @@
+module ApiGenerator
+  module Models
+    class Data < Base
+      property :namespace
+      property :action
+      property :http_method
+      property :paginate
+      property :app_name
+      property :app_short_name
+
+      def for_template
+        binding
+      end
+    end
+  end
+end

data/lib/api_generator/pagination/dsl.rb

@@ -0,0 +1,32 @@
+module ApiGenerator::Pagination
+  module Dsl
+    STRATEGIES = {
+      limit_offset: LimitOffsetRelation,
+      page: PageRelation,
+    }.freeze
+
+    # rubocop:disable Metrics/MethodLength
+    # @param [Array<Symbol] methods список методов для применения пагинации
+    # @param [Symbol, Class] with стратегия пагинации (например, :limit_offset, :page)
+    # @param data_key ключ, по которому можно получить массив данных в ответе
+    # @param [Proc] on_request
+    #   коллбэк, вызываемый при запросе и принимающий как аргументы запрос и параметры
+    # @param [Hash] config дополнительная конфигурация для стратегии пагинации
+    def paginate(*methods, with:, data_key:, on_request:, **config)
+      relation_class = STRATEGIES.fetch(with, with)
+
+      prepend(
+        Module.new do
+          methods.each do |method|
+            define_method(method) do |*args|
+              relation_class.new(config.merge(data_key: data_key)) do |relation|
+                super(*args) { |req| on_request.call(req, **relation.request_options) }
+              end
+            end
+          end
+        end,
+      )
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/api_generator/pagination/limit_offset_relation.rb

@@ -0,0 +1,24 @@
+class ApiGenerator::Pagination::LimitOffsetRelation < ApiGenerator::Pagination::Relation
+  def limit(limit)
+    expand(limit: limit)
+  end
+
+  def offset(offset)
+    expand(offset: offset)
+  end
+
+  private
+
+  def next_relation
+    limit = config[:limit]&.call(response) || size
+    offset = config[:offset]&.call(response) || options[:offset].to_i
+
+    expand(offset: offset + limit)
+  end
+
+  def last_page?
+    return size < config[:limit].call(response) if config[:limit]
+
+    data.empty?
+  end
+end

data/lib/api_generator/pagination/page_relation.rb

@@ -0,0 +1,21 @@
+class ApiGenerator::Pagination::PageRelation < ApiGenerator::Pagination::Relation
+  def page(page)
+    expand(page: page)
+  end
+
+  def per(size)
+    expand(per_page: size)
+  end
+
+  private
+
+  def next_relation
+    expand(page: [options[:page].to_i, 1].max + 1)
+  end
+
+  def last_page?
+    return data.size < config[:per_page].call(response) if config[:per_page]
+
+    data.empty?
+  end
+end