aws-sdk-core 2.0.48 → 2.1.0

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

@@ -1,75 +0,0 @@
-module Aws
-  module Api
-    class Customizer
-
-      # @api private
-      def initialize(client_class)
-        @client_class = client_class
-        @api = client_class.api
-      end
-
-      # @return [Class<Seahorse::Client::Base>]
-      attr_reader :client_class
-
-      # @return [Seahorse::Model::Api]
-      attr_reader :api
-
-      # @api private
-      def apply(&customizations)
-        instance_eval(&customizations)
-      end
-
-      # @param [String, Class<Seahorse::Client::Plugin>] plugin
-      def add_plugin(plugin)
-        @client_class.add_plugin(plugin)
-      end
-
-      # @param [String, Class<Seahorse::Client::Plugin>] plugin
-      def remove_plugin(plugin)
-        @client_class.remove_plugin(plugin)
-      end
-
-      def metadata(key, value)
-        @client_class.api.definition['metadata'][key] = value
-      end
-
-      def add_shape(shape_name, definition)
-        @client_class.api.definition['shapes'][shape_name] = definition
-      end
-
-      def reshape(shape_name, modifications)
-        shape = @client_class.api.definition['shapes'][shape_name]
-        shape = deep_merge(shape, modifications)
-        @client_class.api.definition['shapes'][shape_name] = shape
-      end
-
-      def reshape_members(member_regex, modifications)
-        if member_regex.is_a?(String)
-          member_regex = /^#{member_regex}$/
-        end
-        @client_class.api.definition['shapes'].each_value do |shape|
-          if shape['members']
-            shape['members'].each do |member_name, member_ref|
-              if member_name.match(member_regex)
-                shape['members'][member_name] = deep_merge(member_ref, modifications)
-              end
-            end
-          end
-        end
-      end
-
-      def each_operation(&block)
-        @client_class.api.definition['operations'].each(&block)
-      end
-
-      private
-
-      def deep_merge(first_hash, other_hash)
-        first_hash.merge(other_hash) do |key, old, new|
-          Hash === old && Hash === new ? deep_merge(old, new) : new
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Aws
-  module Api
-    # @api private
-    # This module loads the API documentation for the given API.
-    module Docstrings
-
-      def self.apply(client_class, path)
-        api = client_class.api.definition
-        docs = File.open(path, 'r', encoding: 'UTF-8') { |f| f.read }
-        docs = MultiJson.load(docs)
-
-        api['documentation'] = docs['service']
-
-        docs['operations'].each do |operation, doc|
-          api['operations'][operation]['documentation'] = doc
-        end
-
-        docs['shapes'].each do |shape_name, shape|
-          api['shapes'][shape_name]['documentation'] = shape['base']
-          shape['refs'].each do |ref,doc|
-            if doc.nil?
-              doc = shape['base']
-            end
-            target_shape_name, member = ref.split('$')
-            target_shape = api['shapes'][target_shape_name]
-            case target_shape['type']
-            when 'structure' then target_shape['members'][member]['documentation'] = doc
-            when 'list' then target_shape[member]['documentation'] = doc
-            when 'map' then target_shape[member]['documentation'] = doc
-            else raise 'not handled'
-            end
-          end
-        end
-        client_class.set_api(Seahorse::Model::Api.new(api))
-      end
-    end
-  end
-end

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

@@ -1,241 +0,0 @@
-require 'erb'
-
-module Aws
-  module Api
-    class Documenter
-
-      def initialize(svc_module, docs_path)
-        @svc_module = svc_module
-        @svc_name = svc_module.name.split('::').last
-        @client_class = svc_module.const_get(:Client)
-        Aws::Api::Docstrings.apply(@client_class, docs_path)
-        @api = @client_class.api
-        @full_name = @api.metadata('serviceFullName')
-        @error_names = @api.operations.map {|_,o| o.errors.map(&:name) }
-        @error_names = @error_names.flatten.uniq.sort
-        @namespace = YARD::Registry['Aws']
-      end
-
-      def apply
-        document_service
-        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.exists?(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.exists?(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 client_docstring
-        path = "doc-src/services/#{@svc_name}/client.md"
-        path = 'doc-src/services/default/client.md' unless File.exists?(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)
-        m = YARD::CodeObjects::MethodObject.new(namespace, method_name)
-        m.group = 'Service Operations'
-        m.scope = :instance
-        m.parameters << ['params', '{}']
-        m.docstring = operation_docstring(method_name, operation)
-      end
-
-      def operation_docstring(method_name, operation)
-
-        documentor = OperationDocumenter.new(
-          svc_var_name: @svc_name.downcase,
-          method_name: method_name,
-          operation: operation)
-
-        tabs = Tabulator.new.tap do |t|
-          t.tab(method_name, 'Formatting Example') do
-            "<pre><code>#{documentor.example}</code></pre>"
-          end
-          t.tab(method_name, 'Request Parameters') do
-            documentor.input
-          end
-          t.tab(method_name, 'Response Structure') do
-            documentor.output
-          end
-        end
-
-        errors = (operation.errors || []).map { |shape| shape.name }
-        errors = errors.map { |e| "@raise [Errors::#{e}]" }.join("\n")
-
-        docstring = <<-DOCSTRING.strip
-<p>Calls the #{operation.name} operation.<p>
-#{documentor.api_ref(operation)}
-#{tabs}
-@param [Hash] params ({})
-@return [PageableResponse]
-#{errors}
-        DOCSTRING
-      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>Delay</th><th>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

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

@@ -1,173 +0,0 @@
-module Aws
-  module Api
-    class OperationDocumenter
-
-      def initialize(options)
-        @operation = options[:operation]
-        @example = OperationExample.new(options)
-      end
-
-      def input
-        params(nil) do
-          if @operation.input
-            lines = []
-            if @operation.output
-              lines << '<div class="param"><div class="entry"><span class="key">:response_target</span> => String, Pathname, File</div>Optional path to a file or file object where the HTTP response body should be written.</div>'
-            end
-            lines + structure(@operation.input, [])
-          else
-            []
-          end
-        end.join
-      end
-
-      def output
-        params(nil) do
-          if @operation.output
-            structure(@operation.output, [])
-          else
-            []
-          end
-        end.join
-      end
-
-      def example
-        @example
-      end
-
-      def clean(docs)
-        docs = docs.gsub(/<!--.*?-->/m, '')
-        docs = docs.gsub(/<examples?>.+?<\/examples?>/m, '')
-        docs = docs.gsub(/<\/?note>/m, '')
-        docs = docs.gsub(/\{(\S+)\}/, '`{\1}`')
-        docs = docs.gsub(/\s+/, ' ').strip
-        docs
-      end
-
-      def api_ref(shape)
-        docs = shape.nil? ? '' : shape.documentation
-        if docs && !docs.empty?
-          "<div class=\"api-ref\">#{clean(docs)}</div>"
-        end
-      end
-
-      private
-
-      def params(shape, &block)
-        if shape && shape.name == 'AttributeValue'
-          ['<p>An attribute value may be one of:<ul><li>`Hash`</li><li>`Array`</li><li>`String`</li><li>`Numeric`</li><li>`true` | `false`</li><li>`nil`</li><li>`IO`</li><li>`Set<String,Numeric,IO>`</li></ul></p>']
-        else
-          ['<div class="params">', api_ref(shape)] + yield + ['</div>']
-        end
-      end
-
-      def param(shape, key_name, value_type, required, visited, &block)
-        lines = []
-        lines << '<div class="param">'
-        lines << entry(shape, key_name, value_type, required, visited)
-
-        if visited.include?(shape)
-          lines << "AttributeValue, recursive"
-        else
-          visited = visited + [shape]
-          yield(lines) if block_given?
-          lines += nested_params(shape, visited)
-        end
-
-        lines << '</div>'
-        lines
-      end
-
-      def nested_params(shape, visited)
-        if leaf?(shape)
-          nested(shape, visited)
-        else
-          params(shape) { nested(shape, visited) }
-        end
-      end
-
-      def nested(shape, visited)
-        case shape
-        when Seahorse::Model::Shapes::Structure then structure(shape, visited)
-        when Seahorse::Model::Shapes::Map then map(shape, visited)
-        when Seahorse::Model::Shapes::List then list(shape, visited)
-        else [api_ref(shape)]
-        end
-      end
-
-      def structure(shape, visited)
-        shape.members.inject([]) do |lines, (member_name, member_shape)|
-          lines += param(member_shape, member_name, shape_type(member_shape), shape.required.include?(member_name), visited)
-        end
-      end
-
-      def map(shape, visited)
-        param(shape.value, key_name(shape), value_type(shape), false, visited)
-      end
-
-      def list(shape, visited)
-        case shape.member
-        when Seahorse::Model::Shapes::Structure then structure(shape.member, visited)
-        when Seahorse::Model::Shapes::Map then map(shape.member, visited)
-        when Seahorse::Model::Shapes::List then raise NotImplementedError
-        else [api_ref(shape)]
-        end
-      end
-
-      def entry(shape, key_name, value_type, required, visited)
-        classes = ['key']
-        classes << 'required' if required
-        line = '<div class="entry">'
-        line << "<span class=\"#{classes.join(' ')}\">#{key_name.inspect}</span>"
-        line << " => #{value_type}"
-        line << '</div>'
-        line
-      end
-
-      def shape_type(shape)
-        case shape
-        when Seahorse::Model::Shapes::Structure then 'Hash'
-        when Seahorse::Model::Shapes::Map then 'Hash'
-        when Seahorse::Model::Shapes::List then "Array&lt;#{value_type(shape)}&gt;"
-        when Seahorse::Model::Shapes::String then 'String'
-        when Seahorse::Model::Shapes::Timestamp then 'Time'
-        when Seahorse::Model::Shapes::Integer then 'Integer'
-        when Seahorse::Model::Shapes::Float then 'Number'
-        when Seahorse::Model::Shapes::Boolean then 'Boolean'
-        when Seahorse::Model::Shapes::Blob then 'String,IO'
-        else raise "unhandled type #{shape.type}"
-        end
-      end
-
-      def key_type(shape)
-        shape_type(shape.key)
-      end
-
-      def value_type(shape)
-        case shape
-        when Seahorse::Model::Shapes::List then shape_type(shape.member)
-        when Seahorse::Model::Shapes::Map then shape_type(shape.value)
-        else raise 'stop'
-        end
-      end
-
-      def key_name(shape)
-        shape.key.metadata('shape')
-      end
-
-      def value_name(shape)
-        shape.members.metadata('shape')
-      end
-
-      def leaf?(shape)
-        case shape
-        when Seahorse::Model::Shapes::Structure then false
-        when Seahorse::Model::Shapes::Map then false
-        when Seahorse::Model::Shapes::List then leaf?(shape.member)
-        else true
-        end
-      end
-
-    end
-  end
-end