ruby-ant-server 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41ee7dcbdca9427ffd33f13adb474decf81c6dc7a15b6e2737d7bf43bf047183
+  data.tar.gz: 8ae42f2484ab308f7f44856a5dd580c4d10b5711dffb49e9132483ee8eedcf43
+SHA512:
+  metadata.gz: f04d0fb5168cb1834f87f2b4b4d28f48c8e85dc7ab64b594790c6f6790337782f33b78e23c2da01ccfffc313aecb823a2d39dfccbd912ce5781921e7e5a5665d
+  data.tar.gz: 07704b5849e8fb0a3c9a903d49d7d7f16719d1009b4bae03d8a11136013d7b01bfd126afe3a3ee85b9861316ad05a1553dd6f6014d7a09cdb531206a1afce153

data/lib/ant.rb

@@ -0,0 +1,4 @@
+require_relative 'ant/version'
+require_relative 'ant/exceptions'
+require_relative 'ant/server/response'
+require_relative 'ant/server/format'

data/lib/ant/client.rb

@@ -0,0 +1,2 @@
+require 'ant'
+require 'ant/client/rest_client'

data/lib/ant/client/format/format.rb

@@ -0,0 +1,22 @@
+require_relative 'json_format'
+require_relative 'url_encoded'
+
+module Ant
+  module Client
+    module Format
+      class << self
+        def build(config)
+          @formats ||= default_formats
+          @formats[config[:format]].new
+        end
+
+        def default_formats
+          {
+            json: JSONFormat,
+            url_encoded: URLEncodedFormat
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/format/json_format.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Ant
+  module Client
+    module Format
+      class JSONFormat
+        def pack(data)
+          {
+            body: data.to_json,
+            headers: { 'Content-type' => 'application/json; charset=UTF-8',
+                       'User-Agent' => 'Ruby Ant Client' }
+          }
+        end
+
+        def unpack(data)
+          unformat(data.body)
+        end
+
+        def unformat(msg)
+          JSON.parse(msg, symbolize_names: true)
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/format/url_encoded.rb

@@ -0,0 +1,21 @@
+require_relative 'json_format'
+
+module Ant
+  module Client
+    module Format
+      class URLEncodedFormat < JSONFormat
+        def pack(data)
+          {
+            body: encode(data),
+            headers: { 'Content-type' =>
+                       'application/x-www-form-urlencoded; charset=UTF-8' }
+          }
+        end
+
+        def encode(data)
+          data.map { |k, v| "#{k}=#{v}" }.join('&')
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/rest_client.rb

@@ -0,0 +1,49 @@
+require 'httparty'
+
+require_relative 'session/base'
+require_relative 'format/format'
+require_relative 'validator'
+
+module Ant
+  module Client
+    class RESTClient
+      def initialize(configs)
+        @session = Session.build(configs)
+        @config = configs
+        @format = Format.build(configs)
+        @endpoint = configs[:endpoint]
+        @validator = Validator.build(configs)
+      end
+
+      def get(path, data = {})
+        perform_request(:get, path, data)
+      end
+
+      def post(path, data = {})
+        perform_request(:post, path, data)
+      end
+
+      def put(path, data = {})
+        perform_request(:put, path, data)
+      end
+
+      def delete(path, data = {})
+        perform_request(:delete, path, data)
+      end
+
+      def patch(path, data = {})
+        perform_request(:patch, path, data)
+      end
+
+      private
+
+      def perform_request(method, path, data)
+        log_debug('Performing request', method: method, path: path, data: data)
+        result = @session.perform_request(method, "#{@endpoint}#{path}",
+                                          @format.pack(data))
+        unpacked = @format.unpack(result)
+        @validator.validate(unpacked)
+      end
+    end
+  end
+end

data/lib/ant/client/session/base.rb

@@ -0,0 +1,29 @@
+require 'httparty'
+require_relative 'basic_auth'
+
+module Ant
+  module Client
+    module Session
+      def self.build(config)
+        Base.new(config)
+      end
+
+      class Base
+        include HTTParty
+        include BasicAuth
+        def initialize(config)
+          @config = config
+        end
+
+        def configure_request(request)
+          basic_auth(request, @config[:basic_auth]) if @config[:basic_auth]
+        end
+
+        def perform_request(method, endpoint, data)
+          configure_request(data)
+          self.class.send(method, endpoint, data)
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/session/basic_auth.rb

@@ -0,0 +1,11 @@
+module Ant
+  module Client
+    module Session
+      module BasicAuth
+        def basic_auth(request, user:, password:)
+          request[:basic_auth] ||= { username: user, password: password }
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/session/ssl_client_certificate.rb

@@ -0,0 +1,11 @@
+module Ant
+  module Client
+    module Session
+      module SSLClientCertificate
+        def ssl_certificate(_cert, _key)
+          puts 'TODO: write cert'
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/validator.rb

@@ -0,0 +1,24 @@
+require_relative 'validator/jsend'
+require_relative 'validator/no_validator'
+
+module Ant
+  module Client
+    module Validator
+      class << self
+        def build(config)
+          config[:validator] ||= :none
+          @validators ||= default_validators
+          @validators[config[:validator]].new
+        end
+
+        def default_validators
+          {
+            jsend: JSend,
+            empty: NoValidator,
+            none: NoValidator
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/validator/jsend.rb

@@ -0,0 +1,29 @@
+require 'ant'
+module Ant
+  module Client
+    module Validator
+      class JSend
+        include Ant::Exceptions
+        EXCEPTION_LIST = {
+          'fail' => AntFail,
+          'error' => AntError,
+          'fatal' => AntError
+        }.freeze
+
+        def validate(response)
+          case response[:status]
+          when 'success'
+            response[:data]
+          when 'fail', 'error', 'fatal'
+            exception_klass = EXCEPTION_LIST[response[:status]]
+            raise exception_klass.new(response[:message],
+                                      response[:code],
+                                      response[:data])
+          else
+            raise(AntError, 'Unknown Error')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ant/client/validator/no_validator.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+module Ant
+  module Client
+    module Validator
+      class NoValidator
+        def validate(response)
+          response
+        end
+      end
+    end
+  end
+end

data/lib/ant/dry/daemon.rb

@@ -0,0 +1,31 @@
+module Ant
+  module DRY
+    class Daemon
+      def initialize(wait_time, attach, proc)
+        @proc = proc
+        @wait_time = wait_time
+        @attach = attach
+        @finish = false
+      end
+
+      def task
+        loop do
+          begin
+            @proc.exec
+          rescue StandarError => ex
+            log_error('Unexpected error', error: ex)
+          end
+          sleep(@wait_time)
+        end
+      end
+
+      def run
+        if @attach
+          task
+        else
+          Thread.new(&:task)
+        end
+      end
+    end
+  end
+end

data/lib/ant/dry/resource_injector.rb

@@ -0,0 +1,63 @@
+module Ant
+  module DRY
+    ##
+    # Provides a method for sending external dependencies
+    # to classes, like database connections, configurations,
+    # and other objects that can vary but does not modify
+    # the class functionality.
+    # This class works a decorator to be just extended
+    # by classes
+    #
+    #  class Controller
+    #    extend ResourceInjector
+    #  end
+    module ResourceInjector
+      # Initialices the resources value and returns the object.
+      # This method should not be used from the out context.
+      # Resources are grouped by key
+      def resources(key)
+        @resources ||= {}
+        @resources[key] ||= {}
+        @resources[key]
+      end
+
+      # Provides the interface for sending objects inside the class.
+      # The resources have a group and sub group.
+      # When no group is given, it will be added to the :root group
+      # ==== Examples
+      #   Controller.inject(:magic_number, 42)
+      #   Controller.inject(:databases, :database_conection, Sequel.connect)
+      def register(key, subkey, value = nil)
+        if value.nil?
+          value = subkey
+          subkey = key
+          key = :root
+        end
+        resources(key)[subkey] = value
+      end
+
+      # Provides the inside interface for fetching the objects that were
+      # previously provided from the external world.
+      # Also, when no subgroup is given, the key is fetched from :root
+      # ==== Examples
+      #   class Controller
+      #     def initialize
+      #       @magic_number = self.class.resource(:magic_number)
+      #     end
+      #
+      #     def self.factory(id)
+      #       db = resource(:databases, :database_conection)
+      #     end
+      #   end
+      def resource(key, subkey = nil)
+        if subkey.nil?
+          subkey = key
+          key = :root
+        end
+        res = resources(key)[subkey]
+        raise("Resource `#{key}::#{subkey}` Not Found") if res.nil?
+        res
+      end
+    end
+  end
+end

data/lib/ant/exceptions.rb

@@ -0,0 +1,44 @@
+module Ant
+  module Exceptions
+    ##
+    # Exception used as standard error on this gem.
+    # @param message.  This param is meant to be read by another developer
+    #                  It would be nice if the message were self descriptive
+    #                  enough so the developer won't need to ask the creator
+    #                  of the app for help.
+    # @param code.     The code is similar to message, but for this case
+    #                  it is meant to be used for the program to handle
+    #                  exceptions and to make easier to identify the exception..
+    #                  The default is the exception class, so it won't change
+    #                  almost never.
+    # @param data.     Contains additional data to detail the error.
+    class AntBaseException < StandardError
+      attr_reader :message, :code, :data
+      def initialize(message, code, data)
+        @message = message
+        @code = code
+        @data = data
+      end
+    end
+
+    ##
+    # Is used to express a problem with the client's request.
+    class AntFail < AntBaseException
+      def initialize(message, code = nil, data = {})
+        code ||= self.class.name.split('::').last
+        super(message, code, data)
+      end
+    end
+
+    ##
+    # Is used to express an error that was found during the execution of the
+    # program but it also means that the invoked endpoint has not the power to
+    # fix it, so it will only complain.
+    class AntError < AntBaseException
+      def initialize(message, code = nil, data = {})
+        code ||= self.class.name.split('::').last
+        super(message, code, data)
+      end
+    end
+  end
+end

data/lib/ant/server/format.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ant
+  module Server
+    ##
+    # See Exceptions module, since this is based on the exceptions too.
+    # This will wrap a json object into a standard format, where the response
+    # will contain some metadata about the status of the request
+    class Format
+      INTERNAL_SERVER_ERROR_CODE = 'INTERNAL_SERVER_ERROR'.freeze
+      INTERNAL_SERVER_ERROR_MESSAGE = 'Unexpected error ocurred!'.freeze
+      ##
+      # success means there were no errors during the execution of the request
+      # it sends the result in the data field.
+      def success(response)
+        { status: :success, data: response.result }
+      end
+
+      ##
+      # an error on the request. It gives the details of the error.
+      def fail(response)
+        error_format(:fail, response.code, response.message, response.data)
+      end
+
+      ##
+      # an error found while resolving the request.
+      def error(response)
+        error_format(:error, response.code, response.message, response.data)
+      end
+
+      ##
+      # an unhandled error ocurred during the execution of the request.
+      def fatal(_data)
+        error_format(:fatal, INTERNAL_SERVER_ERROR_CODE,
+                     INTERNAL_SERVER_ERROR_MESSAGE, {})
+      end
+
+      ##
+      # helper to sumarize fatal and error status
+      def error_format(level, code, message, data)
+        { status: level, code: code, message: message, data: data }
+      end
+    end
+  end
+end

data/lib/ant/server/grape.rb

@@ -0,0 +1,60 @@
+module Ant
+  module Server
+    module GrapeDecorator
+      def self.handler
+        lambda do |env, level, ex|
+          params = env['api.endpoint'].params
+          request = env['api.endpoint'].request
+          pkg = RequestResponse.new(request: request, params: params)
+          pkg.exception = ex
+          Server::Response.logger.send(level, pkg)
+          Server::Response.format.send(level, pkg)
+        end
+      end
+
+      HTTP_CODES = {
+        success: 200, fail: 400, error: 500, fatal: 500
+      }.freeze
+
+      def self.extract_http_code(exception, level)
+        default = HTTP_CODES[level] || 500
+        exception.respond_to?(:http_code) ? exception.http_code : default
+      end
+
+      def self.configure_handlers(base)
+        Server::Response.resources(:exceptions).each do |exception_class, level|
+          base.rescue_from(exception_class) do |ex|
+            response = Ant::Server::GrapeDecorator.handler.call(env, level, ex)
+            http_code = Ant::Server::GrapeDecorator.extract_http_code(ex, level)
+            error!(response, http_code)
+          end
+        end
+        base.rescue_from(:all) do |ex|
+          level = :fatal
+          response = Ant::Server::GrapeDecorator.handler.call(env, level, ex)
+          http_code = Ant::Server::GrapeDecorator.extract_http_code(ex, level)
+          error!(response, http_code)
+        end
+      end
+
+      def self.included(base)
+        base.formatter(:json, lambda do |response, _|
+          pkg = RequestResponse.new(request: {}, params: {})
+          pkg.result = response
+          Server::Response.format.send(:success, pkg).to_json
+        end)
+        configure_logger(base)
+        configure_handlers(base)
+      end
+
+      def self.configure_logger(base)
+        base.after do
+          params = env['api.endpoint'].params
+          request = env['api.endpoint'].request
+          pkg = RequestResponse.new(request: request, params: params)
+          Server::Response.logger.access(pkg)
+        end
+      end
+    end
+  end
+end

data/lib/ant/server/logger.rb

@@ -0,0 +1,42 @@
+require 'cute_logger'
+module Ant
+  module Server
+    class CuteLogger
+      def access_data(response)
+        {
+          path: response.path,
+          ip: response.ip,
+          verb: response.verb
+        }
+      end
+
+      def access(response)
+        log_info('Requesting resource', access_data(response))
+      end
+
+      def success(response)
+        log_info('Success request', access_data(response))
+      end
+
+      def fail(response)
+        log_info('Fail Response',
+                 access_data(response)
+                  .merge(message: response.exception.message))
+      end
+
+      def error(response)
+        log_warn('Error dectected on response', access_data(response).merge(
+                                                  error: response.exception
+        ))
+      end
+
+      def fatal(response)
+        log_error('Unexpected error on response',
+                  access_data(response).merge(
+                    error: response.exception,
+                    data: response.params
+                  ))
+      end
+    end
+  end
+end

data/lib/ant/server/request_response.rb

@@ -0,0 +1,36 @@
+module Ant
+  module Server
+    class RequestResponse
+      attr_reader :params, :exception, :result
+      attr_writer :exception, :result
+      def initialize(request:, params:)
+        @request = request
+        @params = params
+      end
+
+      def data
+        @exception.data
+      end
+
+      def code
+        @exception.code
+      end
+
+      def verb
+        @request.request_method
+      end
+
+      def ip
+        @request.ip
+      end
+
+      def message
+        @exception.message
+      end
+
+      def path
+        @request.url
+      end
+    end
+  end
+end

data/lib/ant/server/response.rb

@@ -0,0 +1,79 @@
+require_relative '../exceptions'
+require_relative '../dry/resource_injector'
+require_relative 'format'
+require_relative 'logger'
+require_relative 'request_response'
+
+module Ant
+  module Server
+    ##
+    # This module provides a function to wrap lambdas arround grape/sinatra
+    # You can mount this module as helper in your application and wrap the block
+    # with the method `process_request`
+    module Response
+      include Exceptions
+      extend DRY::ResourceInjector
+
+      class << self
+        attr_reader :logger, :format
+
+        def log_mode(mode)
+          @logger = resource(:loggers, mode)
+        end
+
+        def format_mode(mode)
+          @format = resource(:formats, mode)
+        end
+
+        def recover_from!(exception_class, level)
+          register(:exceptions, exception_class, level)
+        end
+
+        def configure_defaults!
+          recover_from!(Exceptions::AntFail, :fail)
+          recover_from!(Exceptions::AntError, :error)
+          register(:loggers, :cute_logger, Server::CuteLogger.new)
+          register(:formats, :jsend, Server::Format.new)
+          log_mode(:cute_logger)
+          format_mode(:jsend)
+        end
+      end
+
+      def exception_handler(exception)
+        Server::Response.resources(:exceptions).each do |klass, recover|
+          return recover if exception.is_a?(klass)
+        end
+        exception.is_a?(StandardError) ? :fatal : nil
+      end
+
+      def handle(resolver, data)
+        if resolver
+          Server::Response.logger.send(resolver, data)
+          Server::Response.format.send(resolver, data)
+        else
+          Server::Response.logger.fatal(data)
+          raise(data.exception)
+        end
+      end
+
+      def process_request
+        data = RequestResponse.new(request: request, params: params)
+        resolver = :success
+        Server::Response.logger.access(data)
+        begin
+          raise(AntError, 'No implementation given') unless block_given?
+          data.result = yield
+          # rubocop: disable RescueException
+        rescue Exception => ex
+          # rubocop: enable RescueException
+          data.exception = ex
+          resolver = exception_handler(ex)
+        end
+        handle(resolver, data)
+      end
+    end
+  end
+end
+
+# Allow backwards compatibility
+Ant::Server::Response.configure_defaults!

data/lib/ant/version.rb

@@ -0,0 +1,3 @@
+module Ant
+  VERSION = '0.4.1'.freeze
+end

metadata

@@ -0,0 +1,248 @@
+--- !ruby/object:Gem::Specification
+name: ruby-ant-server
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Gilberto Vargas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cute_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gems can be used along a server app with jsonformat messages
+email:
+- tachoguitar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ant.rb
+- lib/ant/client.rb
+- lib/ant/client/format/format.rb
+- lib/ant/client/format/json_format.rb
+- lib/ant/client/format/url_encoded.rb
+- lib/ant/client/format/xml_format.rb
+- lib/ant/client/rest_client.rb
+- lib/ant/client/session/base.rb
+- lib/ant/client/session/basic_auth.rb
+- lib/ant/client/session/ssl_client_certificate.rb
+- lib/ant/client/validator.rb
+- lib/ant/client/validator/jsend.rb
+- lib/ant/client/validator/no_validator.rb
+- lib/ant/dry/daemon.rb
+- lib/ant/dry/resource_injector.rb
+- lib/ant/exceptions.rb
+- lib/ant/server/format.rb
+- lib/ant/server/grape.rb
+- lib/ant/server/logger.rb
+- lib/ant/server/request_response.rb
+- lib/ant/server/response.rb
+- lib/ant/version.rb
+homepage: https://github.com/KueskiEngineering/ruby-ant-server
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Implements ANT format on server applications
+test_files: []