aws-sdk-core 2.3.23 → 3.89.1

data/lib/aws-sdk-core/acm.rb

@@ -1,6 +0,0 @@
-Aws.add_service(:ACM, {
-  api: "#{Aws::API_DIR}/acm/2015-12-08/api-2.json",
-  docs: "#{Aws::API_DIR}/acm/2015-12-08/docs-2.json",
-  examples: "#{Aws::API_DIR}/acm/2015-12-08/examples-1.json",
-  paginators: "#{Aws::API_DIR}/acm/2015-12-08/paginators-1.json",
-})

data/lib/aws-sdk-core/api/builder.rb

@@ -1,106 +0,0 @@
-require 'set'
-
-module Aws
-  module Api
-    class Builder
-      class << self
-
-        def build(definition, options = {})
-          if Seahorse::Model::Api === definition
-            definition
-          else
-            Builder.new.build(customize(load_definition(definition)), options)
-          end
-        end
-
-        private
-
-        def load_definition(definition)
-          case definition
-          when nil then {}
-          when Hash then definition
-          when String, Pathname then Json.load_file(definition)
-          else raise ArgumentError, "invalid api definition #{definition}"
-          end
-        end
-
-        def customize(definition)
-          Customizations.apply_api_customizations(definition)
-          definition
-        end
-
-      end
-
-      # @param [Hash] definition
-      # @return [Seahorse::Model::Api]
-      def build(definition, options = {})
-        api = build_api(definition)
-        docs = build_docstring_provider(api, options)
-        shapes = build_shape_map(definition, api, docs)
-        build_operations(definition, api, shapes, docs)
-        build_struct_classes(shapes, options)
-        api
-      end
-
-      private
-
-      def build_docstring_provider(api, options)
-        if options[:docs] && ENV['DOCSTRINGS']
-          docs = Json.load_file(options[:docs])
-          Customizations.apply_doc_customizations(api, docs)
-          Docs::DocstringProvider.new(docs)
-        else
-          Docs::NullDocstringProvider.new
-        end
-      end
-
-      def build_api(definition)
-        api = Seahorse::Model::Api.new
-        api.metadata = definition['metadata'] || {}
-        api.version = api.metadata['apiVersion']
-        api
-      end
-
-      def build_shape_map(definition, api, docs)
-        shapes = definition['shapes'] || {}
-        api.metadata['shapes'] = ShapeMap.new(shapes, docs: docs)
-      end
-
-      def build_operations(definitions, api, shapes, docs)
-        (definitions['operations'] || {}).each do |name, definition|
-          operation = build_operation(name, definition, shapes, docs)
-          api.add_operation(underscore(name), operation)
-        end
-      end
-
-      def build_operation(name, definition, shapes, docs)
-        http = definition['http'] || {}
-        op = Seahorse::Model::Operation.new
-        op.name = name
-        op.http_method = http['method']
-        op.http_request_uri = http['requestUri'] || '/'
-        op.documentation = docs.operation_docs(name)
-        op.deprecated = !!definition['deprecated']
-        op.input = shapes.shape_ref(definition['input'])
-        op.output = shapes.shape_ref(definition['output'])
-        op['authtype'] = definition['authtype'] unless definition['authtype'].nil?
-        (definition['errors'] || []).each do |error|
-          op.errors << shapes.shape_ref(error)
-        end
-        op
-      end
-
-      def build_struct_classes(shapes, options)
-        type_builder = options[:type_builder] || TypeBuilder.new(Module.new)
-        shapes.each_structure do |shape|
-          shape[:struct_class] = type_builder.build_type(shape, shapes)
-        end
-      end
-
-      def underscore(str)
-        Seahorse::Util.underscore(str).to_sym
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-core/api/customizations.rb

@@ -1,217 +0,0 @@
-module Aws
-  module Api
-    module Customizations
-
-      @apis = {}
-      @docs = {}
-      @plugins = {}
-
-      class << self
-
-        def api(prefix, &block)
-          @apis[prefix] = block
-        end
-
-        def doc(prefix, &block)
-          @docs[prefix] = block
-        end
-
-        def plugins(prefix, options)
-          @plugins[prefix] = {
-            add: options[:add] || [],
-            remove: options[:remove] || [],
-          }
-        end
-
-        def apply_api_customizations(api)
-          metadata = api['metadata'] || {}
-          prefix = metadata['endpointPrefix']
-          @apis[prefix].call(api) if @apis[prefix]
-        end
-
-        def apply_doc_customizations(api, docs)
-          prefix = api.metadata['endpointPrefix']
-          @docs[prefix].call(docs) if @docs[prefix]
-        end
-
-        def apply_plugins(client_class)
-          prefix = client_class.api.metadata['endpointPrefix']
-          if @plugins[prefix]
-            @plugins[prefix][:add].each { |p| client_class.add_plugin(p) }
-            @plugins[prefix][:remove].each { |p| client_class.remove_plugin(p) }
-          end
-        end
-
-      end
-
-      plugins('apigateway',
-        add: %w(Aws::Plugins::APIGatewayHeader),
-      )
-
-      api('cloudfront') do |api|
-
-        api['shapes'].each do |_, shape|
-          if shape['members'] && shape['members']['MaxItems']
-            shape['members']['MaxItems']['shape'] = 'integer'
-          end
-        end
-
-        api['operations'].keys.each do |name|
-          symbolized = name.sub(/\d{4}_\d{2}_\d{2}$/, '')
-          api['operations'][symbolized] = api['operations'].delete(name)
-        end
-
-      end
-
-      plugins('cloudsearchdomain',
-        add: %w(Aws::Plugins::CSDConditionalSigning),
-        remove: %w(Aws::Plugins::RegionalEndpoint),
-      )
-
-      plugins('dynamodb', add: %w(
-        Aws::Plugins::DynamoDBExtendedRetries
-        Aws::Plugins::DynamoDBSimpleAttributes
-        Aws::Plugins::DynamoDBCRC32Validation
-      ))
-
-      api('ec2') do |api|
-        if ENV['DOCSTRINGS']
-          members = api['shapes']['CopySnapshotRequest']['members']
-          members.delete('DestinationRegion')
-          members.delete('PresignedUrl')
-        end
-      end
-
-      plugins('ec2', add: %w(
-        Aws::Plugins::EC2CopyEncryptedSnapshot
-        Aws::Plugins::EC2RegionValidation
-      ))
-
-      api('glacier') do |api|
-        api['shapes']['Timestamp'] = {
-          'type' => 'timestamp',
-          'timestampFormat' => 'iso8601',
-        }
-        api['shapes'].each do |_, shape|
-          if shape['members']
-            shape['members'].each do |name, ref|
-              case name
-              when /date/i then ref['shape'] = 'Timestamp'
-              when 'limit' then ref['shape'] = 'Size'
-              when 'partSize' then ref['shape'] = 'Size'
-              when 'archiveSize' then ref['shape'] = 'Size'
-              end
-            end
-          end
-        end
-      end
-
-      plugins('glacier', add: %w(
-        Aws::Plugins::GlacierAccountId
-        Aws::Plugins::GlacierApiVersion
-        Aws::Plugins::GlacierChecksums
-      ))
-
-      api('importexport') do |api|
-        api['operations'].each do |_, operation|
-          operation['http']['requestUri'] = '/'
-        end
-      end
-
-      api('data.iot') do |api|
-        api['metadata'].delete('endpointPrefix')
-      end
-
-      api('lambda') do |api|
-        api['shapes']['Timestamp']['type'] = 'timestamp'
-      end
-
-      doc('lambda') do |docs|
-        docs['shapes']['Blob']['refs']['UpdateFunctionCodeRequest$ZipFile'] =
-          "<p>.zip file containing your packaged source code.</p>"
-      end
-
-      plugins('machinelearning', add: %w(
-        Aws::Plugins::MachineLearningPredictEndpoint
-      ))
-
-      api('route53') do |api|
-        api['shapes']['PageMaxItems']['type'] = 'integer'
-      end
-
-      plugins('route53', add: %w(
-        Aws::Plugins::Route53IdFix
-      ))
-
-      api('s3') do |api|
-        api['metadata'].delete('signatureVersion')
-        if ENV['DOCSTRINGS']
-          api['shapes']['AccelerateBoolean'] = { 'type' => 'boolean' }
-          api['operations'].each do |operation_name, operation|
-            next if %w(CreateBucket ListBuckets DeleteBucket).include?(operation_name)
-            if input_ref = operation['input']
-              input_shape = api['shapes'][input_ref['shape']]
-              input_shape['members']['UseAccelerateEndpoint'] = {
-                'shape' => 'AccelerateBoolean'
-              }
-            end
-          end
-        end
-
-        api['shapes']['ExpiresString'] = { 'type' => 'string' }
-        %w(HeadObjectOutput GetObjectOutput).each do |shape|
-          members = api['shapes'][shape]['members']
-          # inject ExpiresString directly after Expires
-          api['shapes'][shape]['members'] = members.inject({}) do |h, (k,v)|
-            h[k] = v
-            if k == 'Expires'
-              h['ExpiresString'] = {
-                'shape' => 'ExpiresString',
-                'location' => 'header',
-                'locationName' => 'Expires',
-              }
-            end
-            h
-          end
-        end
-      end
-
-      doc('s3') do |docs|
-        if ENV['DOCSTRINGS']
-          docs['shapes']['AccelerateBoolean'] = {}
-          docs['shapes']['AccelerateBoolean']['refs'] = {}
-          docs['shapes']['AccelerateBoolean']['base'] = 'When <tt>true</tt>, the "https://BUCKETNAME.s3-accelerate.amazonaws.com" endpoint will be used.'
-        end
-      end
-
-      plugins('s3', add: %w(
-        Aws::Plugins::S3Accelerate
-        Aws::Plugins::S3BucketDns
-        Aws::Plugins::S3BucketNameRestrictions
-        Aws::Plugins::S3Expect100Continue
-        Aws::Plugins::S3Http200Errors
-        Aws::Plugins::S3GetBucketLocationFix
-        Aws::Plugins::S3LocationConstraint
-        Aws::Plugins::S3Md5s
-        Aws::Plugins::S3Redirects
-        Aws::Plugins::S3SseCpk
-        Aws::Plugins::S3UrlEncodedKeys
-        Aws::Plugins::S3RequestSigner
-      ))
-
-      api('sqs') do |api|
-        api['metadata']['errorPrefix'] = 'AWS.SimpleQueueService.'
-      end
-
-      plugins('sqs', add: %w(
-        Aws::Plugins::SQSQueueUrls
-        Aws::Plugins::SQSMd5s
-      ))
-
-      plugins('swf', add: %w(
-        Aws::Plugins::SWFReadTimeouts
-      ))
-
-    end
-  end
-end

data/lib/aws-sdk-core/api/docs/builder.rb

@@ -1,220 +0,0 @@
-require 'erb'
-
-module Aws
-  module Api
-    module Docs
-      class Builder
-
-        def self.document(svc_module)
-          new(svc_module).document
-        end
-
-        def initialize(svc_module)
-          @svc_module = svc_module
-          @svc_name = svc_module.name.split('::').last
-          @client_class = svc_module.const_get(:Client)
-          @api = @client_class.api
-          @full_name = @api.metadata['serviceFullName']
-          @error_names = @api.operations.map {|_,o| o.errors.map(&:shape).map(&:name) }
-          @error_names = @error_names.flatten.uniq.sort
-          @namespace = YARD::Registry['Aws']
-        end
-
-        def document
-          document_service
-          document_types
-          document_client
-          document_errors
-        end
-
-        private
-
-        def document_service
-          yard_mod = YARD::CodeObjects::ModuleObject.new(@namespace, @svc_name)
-          yard_mod.docstring = service_docstring
-          yard_mod.docstring.add_tag(YARD::Tags::Tag.new(:service, @svc_name))
-          @namespace = yard_mod
-        end
-
-        def service_docstring
-          path = "doc-src/services/#{@svc_name}/service.md"
-          path = 'doc-src/services/default/service.md' unless File.exist?(path)
-          template = read(path)
-          svc_name = @svc_name
-          api = @api
-          full_name = @full_name
-          ERB.new(template).result(binding)
-        end
-
-        def document_errors
-          yard_mod = YARD::CodeObjects::ModuleObject.new(@namespace, 'Errors')
-          yard_mod.docstring = errors_docstring
-
-          base_error = YARD::CodeObjects::ClassObject.new(yard_mod, 'ServiceError')
-          base_error.docstring = "Base class for all Aws::#{@svc_name} errors."
-          base_error.superclass = YARD::Registry['Aws::Errors::ServiceError']
-
-          @error_names.each do |error_name|
-            error_klass = YARD::CodeObjects::ClassObject.new(yard_mod, error_name)
-            error_klass.superclass = base_error
-          end
-        end
-
-        def errors_docstring
-          path = "doc-src/services/#{@svc_name}/errors.md"
-          path = 'doc-src/services/default/errors.md' unless File.exist?(path)
-          template = read(path)
-          svc_name = @svc_name
-          api = @api
-          full_name = @full_name
-          known_errors = @error_names
-          ERB.new(template).result(binding)
-        end
-
-        def document_client
-          yard_class = YARD::CodeObjects::ClassObject.new(@namespace, 'Client')
-          yard_class.superclass = YARD::Registry['Seahorse::Client::Base']
-          yard_class.docstring = client_docstring
-          document_client_constructor(yard_class)
-          document_client_operations(yard_class)
-          document_client_waiters(yard_class)
-        end
-
-        def document_types
-          namespace = YARD::CodeObjects::ModuleObject.new(@namespace, 'Types')
-          documenter = ClientTypeDocumenter.new(namespace)
-          @api.metadata['shapes'].each_structure do |shape|
-            documenter.document(@api, shape)
-          end
-        end
-
-        def client_docstring
-          path = "doc-src/services/#{@svc_name}/client.md"
-          path = 'doc-src/services/default/client.md' unless File.exist?(path)
-          render(path)
-        end
-
-        def render(path)
-          svc_name = @svc_name
-          api = @api
-          full_name = @full_name
-          ERB.new(File.read(path)).result(binding)
-        end
-
-        def document_client_constructor(namespace)
-          constructor = YARD::CodeObjects::MethodObject.new(namespace, :initialize)
-          constructor.group = 'Constructor'
-          constructor.scope = :instance
-          constructor.parameters << ['options', '{}']
-          constructor.docstring = client_constructor_docstring
-        end
-
-        def client_constructor_docstring
-          <<-DOCS.strip
-Constructs an API client.
-#{client_constructor_options}
-@return [#{@client_class.name}] Returns an API client.
-          DOCS
-        end
-
-        def client_constructor_options
-          options = {}
-          @client_class.plugins.each do |plugin|
-            if p = YARD::Registry[plugin.name]
-              p.tags.each do |tag|
-                if tag.tag_name == 'seahorse_client_option'
-                  option_name = tag.text.match(/.+(:\w+)/)[1]
-                  option_text = "@option options " + tag.text.split("\n").join("\n  ")
-                  options[option_name] = option_text +
-                    "  See {#{plugin.name}} for more details."
-                end
-              end
-            end
-          end
-          options.sort_by { |k,v| k }.map(&:last).join("\n")
-        end
-
-        def document_client_operations(namespace)
-          @api.operations.each do |method_name, operation|
-            document_client_operation(namespace, method_name, operation)
-          end
-        end
-
-        def document_client_operation(namespace, method_name, operation)
-          documenter = OperationDocumenter.new(@svc_name, namespace)
-          documenter.document(method_name, operation)
-        end
-
-        def document_client_waiters(yard_class)
-          m = YARD::CodeObjects::MethodObject.new(yard_class, :wait_until)
-          m.scope = :instance
-          m.parameters << ['waiter_name', nil]
-          m.parameters << ['params', '{}']
-          m.docstring = YARD::Registry['Aws::ClientWaiters#wait_until'].docstring
-
-          waiters = @client_class.waiters.waiter_names.sort.inject('') do |w,name|
-            waiter = @client_class.waiters.waiter(name)
-            operation = waiter.poller.operation_name
-            w << "<tr><td><tt>:#{name}</tt></td><td>{##{operation}}</td><td>#{waiter.delay}</td><td>#{waiter.max_attempts}</td></tr>"
-          end
-          docstring = <<-DOCSTRING
-Returns the list of supported waiters. The following table lists the supported
-waiters and the client method they call:
-<table>
-<thead>
-<tr><th>Waiter Name</th><th>Client Method</th><th>Default Delay:</th><th>Default Max Attempts:</th></tr>
-</thead>
-<tbody>
-#{waiters}
-</tbody>
-</table>
-@return [Array<Symbol>] the list of supported waiters.
-          DOCSTRING
-          m = YARD::CodeObjects::MethodObject.new(yard_class, :waiter_names)
-          m.scope = :instance
-          m.docstring = docstring
-        end
-
-        class Tabulator
-
-          def initialize
-            @tabs = []
-            @tab_contents = []
-          end
-
-          def tab(method_name, tab_name, &block)
-            tab_class = tab_name.downcase.gsub(/[^a-z]+/i, '-')
-            tab_id = "#{method_name.to_s.gsub(/_/, '-')}-#{tab_class}"
-            class_names = ['tab-contents', tab_class]
-            @tabs << [tab_id, tab_name]
-            @tab_contents << "<div class=\"#{class_names.join(' ')}\" id=\"#{tab_id}\">"
-            @tab_contents << yield
-            @tab_contents << '</div>'
-          end
-
-          def to_html
-            lines = []
-            lines << '<div class="tab-box">'
-            lines << '<ul class="tabs">'
-            @tabs.each do |tab_id, tab_name|
-              lines << "<li data-tab-id=\"#{tab_id}\">#{tab_name}</li>"
-            end
-            lines << '</ul>'
-            lines.concat(@tab_contents)
-            lines << '</div>'
-            lines.join
-          end
-          alias inspect to_html
-          alias to_str to_html
-          alias to_s to_html
-
-        end
-
-        def read(path)
-          File.open(path, 'r', encoding: 'UTF-8') { |f| f.read }
-        end
-
-      end
-    end
-  end
-end