aws-sdk-code-generator 0.4.0.pre → 0.5.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4bb64ca30811529d0c5c4149e3d46b7eabef0d3068672ca06ed6d9fc97369f5
-  data.tar.gz: c2e56887b3686a58569da5fa643a8cb69bcca35c4b0f24dbdd67e48c3d3675c8
+  metadata.gz: 3332820d3c044afc9813a785b511cc25fcce3581477a3f05f860bf49bb225ffe
+  data.tar.gz: '09ed058cda2368a87496efc47772d019dfb3f1911732c344c9146af6a51f68fe'
 SHA512:
-  metadata.gz: 3a6b20c93b4c58ef3bfac9e2d48551540106fa907deb17b72bb00876c807a2dbf05079b38634534a18a563a6f0b6affd98564a94a16370ba4e3d7efcf34a1034
-  data.tar.gz: 63b927d59a16241bc32e5ec51d647ae6dcc952c562e9eedccf50451bf62a64065d3833be2b8b0d7ffef6114300068b426bf3a96617c0c97f8bb9932b3ff45605
+  metadata.gz: 4de3ecc3f1f0ff599143e79808c395aa82319da3af73f9c9b87c1d6526f438feb4471e52d68e8559a027223d523c21d89250e2e212c83a53a52c41726a8df7e3
+  data.tar.gz: 9b6d2456bb9bd9fbff1e7beb50c0f93a8137e1eb249cf931107e0f1dca7dc0f92b57da5d011a199900c03a5cd6d6f53b7fd7387cafead162f7aa892dffaea76f

data/lib/aws-sdk-code-generator/client_constructor.rb

@@ -8,7 +8,8 @@ module AwsSdkCodeGenerator
 
     def initialize(options)
       plugin_options = documented_plugin_options(options.fetch(:plugins)) +
-        documented_plugin_options(options.fetch(:codegenerated_plugins))
+        documented_plugin_options(options.fetch(:codegenerated_plugins)) +
+        documented_plugin_options(options.fetch(:default_plugins, []))
       documentation = {}
       plugin_options.each do |option|
         documentation[option.name] = YardOptionTag.new(

data/lib/aws-sdk-code-generator/code_builder.rb

@@ -109,6 +109,58 @@ module AwsSdkCodeGenerator
       end
     end
 
+    # @return [Enumerable<String<path>, String<code>>]
+    def rbs_files(options = {})
+      Enumerator.new do |y|
+        prefix = options.fetch(:prefix, '')
+        codegenerated_plugins = codegen_plugins(prefix)
+        client_class = Views::RBS::ClientClass.new(
+          service_name: @service.name,
+          codegenerated_plugins: codegenerated_plugins,
+          aws_sdk_core_lib_path: @aws_sdk_core_lib_path,
+          legacy_endpoints: @service.legacy_endpoints?,
+          signature_version: @service.signature_version,
+          api: @service.api,
+          waiters: @service.waiters,
+          protocol: @service.protocol,
+          add_plugins: @service.add_plugins,
+          remove_plugins: @service.remove_plugins,
+        )
+        y.yield("#{prefix}/client.rbs", client_class.render)
+        y.yield("#{prefix}/errors.rbs", Views::RBS::ErrorsModule.new(
+          service: @service
+        ).render)
+        y.yield("#{prefix}/resource.rbs", Views::RBS::RootResourceClass.new(
+          service_name: @service.name,
+          client_class: client_class,
+          api: @service.api,
+          resources: @service.resources,
+          paginators: @service.paginators,
+        ).render)
+        y.yield("#{prefix}/waiters.rbs", Views::RBS::WaitersModule.new(
+          service_name: @service.name,
+          api: @service.api,
+          waiters: @service.waiters,
+        ).render)
+        y.yield("#{prefix}/types.rbs", Views::RBS::TypesModule.new(
+          service: @service
+        ).render)
+        if @resources
+          @resources['resources'].keys.sort.each do |class_name|
+            path = "#{prefix}/#{Underscore.underscore(class_name)}.rbs"
+            code = Views::RBS::ResourceClass.new(
+              service_name: @service.name,
+              class_name: class_name,
+              resource: @resources['resources'][class_name],
+              api: @service.api,
+              paginators: @service.paginators,
+            ).render
+            y.yield(path, code)
+          end
+        end
+      end
+    end
+
     private
 
     def service_module(prefix, codegenerated_plugins)

data/lib/aws-sdk-code-generator/eventstream_example.rb

@@ -39,52 +39,53 @@ module AwsSdkCodeGenerator
       <<-EXAMPLE.strip
 # @example Bi-directional EventStream Operation Example
 #
-#   You can signal input events after initial request is
-#   established, events will be sent to stream
-#   immediately (once stream connection is established successfully).
+#   You can signal input events after the initial request is established. Events
+#   will be sent to the stream immediately once the stream connection is
+#   established successfully.
 #
-#   To signal events, you can call #signal methods from an #{@input_eventstream} object.
-#   Make sure signal events before calling #wait or #join! at async response.
+#   To signal events, you can call the #signal methods from an #{@input_eventstream}
+#   object. You must signal events before calling #wait or #join! on the async response.
 #
 #     input_stream = #{@input_eventstream}.new
 #
-#     async_resp = #{@receiver}.#{@method_name}( # params input,
+#     async_resp = #{@receiver}.#{@method_name}(
+#       # params input
 #       input_event_stream_handler: input_stream) do |out_stream|
 #
-#       # register callbacks for events arrival
+#       # register callbacks for events
 #{event_entry(:output, 'out_stream', 2)}
 #
 #     end
-#     # => returns Aws::Seahorse::Client::AsyncResponse
+#     # => Aws::Seahorse::Client::AsyncResponse
 #
 #     # signal events
 #{event_entry(:input, 'input_stream')}
 #
-#     # make sure signaling :end_stream in the end
+#     # make sure to signal :end_stream at the end
 #     input_stream.signal_end_stream
 #
-#     # wait until stream is closed before finalizing sync response
+#     # wait until stream is closed before finalizing the sync response
 #     resp = async_resp.wait
-#     # Or close stream and finalizing sync response immediately
+#     # Or close the stream and finalize sync response immediately
 #     # resp = async_resp.join!
 #
-#   Inorder to streamingly processing events received, you can also provide an #{@output_eventstream}
-#   object to register callbacks before initializing request instead of processing from request block
+#   You can also provide an #{@output_eventstream} object to register callbacks
+#   before initializing the request instead of processing from the request block.
 #
 #     output_stream = #{@output_eventstream}.new
-#     # register callbacks for events arrival
+#     # register callbacks for output events
 #{event_entry(:output, 'output_stream')}
 #{error_event_entry('output_stream')}
 #
-#     async_resp = #{@receiver}.#{@method_name} ( #params input,
+#     async_resp = #{@receiver}.#{@method_name} (
+#       # params input
 #       input_event_stream_handler: input_stream
 #       output_event_stream_handler: output_stream
 #     )
 #
-#     resp = async_resp.wait!
+#     resp = async_resp.join!
 #
-#   Besides above usage patterns for process events when they arrive immediately, you can also
-#   iterate through events after response complete.
+#   You can also iterate through events after the response is complete.
 #
 #   Events are available at #{@resp_var}.#{@output_eventstream_member} # => Enumerator
       EXAMPLE
@@ -94,22 +95,22 @@ module AwsSdkCodeGenerator
       <<-EXAMPLE.strip
 # @example EventStream Operation Example
 #
-#   You can process event once it arrives immediately, or wait until
-#   full response complete and iterate through eventstream enumerator.
+#   You can process the event once it arrives immediately, or wait until the
+#   full response is complete and iterate through the eventstream enumerator.
 #
 #   To interact with event immediately, you need to register ##{@method_name}
-#   with callbacks, callbacks can be register for specifc events or for all events,
-#   callback for errors in the event stream is also available for register.
+#   with callbacks. Callbacks can be registered for specific events or for all
+#   events, including error events.
 #
-#   Callbacks can be passed in by `:event_stream_handler` option or within block
-#   statement attached to ##{@method_name} call directly. Hybrid pattern of both
-#   is also supported.
+#   Callbacks can be passed into the `:event_stream_handler` option or within a
+#   block statement attached to the ##{@method_name} call directly. Hybrid
+#   pattern of both is also supported.
 #
-#   `:event_stream_handler` option takes in either Proc object or
+#   `:event_stream_handler` option takes in either a Proc object or
 #   #{@output_eventstream} object.
 #
-#   Usage pattern a): callbacks with a block attached to ##{@method_name}
-#     Example for registering callbacks for all event types and error event
+#   Usage pattern a): Callbacks with a block attached to ##{@method_name}
+#     Example for registering callbacks for all event types and an error event
 #
 #     #{@receiver}.#{@method_name}( # params input# ) do |stream|
 #{error_event_entry('stream', 2)}
@@ -122,9 +123,9 @@ module AwsSdkCodeGenerator
 #
 #     end
 #
-#   Usage pattern b): pass in `:event_stream_handler` for ##{@method_name}
+#   Usage pattern b): Pass in `:event_stream_handler` for ##{@method_name}
 #
-#     1) create a #{@output_eventstream} object
+#     1) Create a #{@output_eventstream} object
 #     Example for registering callbacks with specific events
 #
 #       handler = #{@output_eventstream}.new
@@ -132,7 +133,7 @@ module AwsSdkCodeGenerator
 #
 #     #{@receiver}.#{@method_name}( # params input #, event_stream_handler: handler)
 #
-#     2) use a Ruby Proc object
+#     2) Use a Ruby Proc object
 #     Example for registering callbacks with specific events
 #
 #     handler = Proc.new do |stream|
@@ -141,7 +142,7 @@ module AwsSdkCodeGenerator
 #
 #     #{@receiver}.#{@method_name}( # params input #, event_stream_handler: handler)
 #
-#   Usage pattern c): hybird pattern of a) and b)
+#   Usage pattern c): Hybrid pattern of a) and b)
 #
 #       handler = #{@output_eventstream}.new
 #{event_entry(:output, 'handler', 2)}
@@ -150,8 +151,7 @@ module AwsSdkCodeGenerator
 #{error_event_entry('stream', 2)}
 #     end
 #
-#   Besides above usage patterns for process events when they arrive immediately, you can also
-#   iterate through events after response complete.
+#   You can also iterate through events after the response complete.
 #
 #   Events are available at #{@resp_var}.#{@output_eventstream_member} # => Enumerator
 #   For parameter input example, please refer to following request syntax

data/lib/aws-sdk-code-generator/gem_builder.rb

@@ -25,7 +25,6 @@ module AwsSdkCodeGenerator
         y.yield('features/step_definitions.rb', features_step_definitions_file)
         if @service.smoke_tests
           y.yield('features/smoke.feature', smoke_file)
-          y.yield('features/smoke_step_definitions.rb', smoke_step_definitions_file)
         end
         y.yield('VERSION', version_file)
         y.yield('LICENSE.txt', license_file)
@@ -37,6 +36,9 @@ module AwsSdkCodeGenerator
         code.spec_files.each do |path, code|
           y.yield("spec/#{path}", code)
         end
+        code.rbs_files.each do |path, code|
+          y.yield("sig/#{path}", code)
+        end
       end.each(&block)
     end
 
@@ -54,10 +56,6 @@ module AwsSdkCodeGenerator
       Views::Features::Smoke.new(options).render
     end
 
-    def smoke_step_definitions_file
-      Views::Features::SmokeStepDefinitions.new(options).render
-    end
-
     def features_step_definitions_file
       Views::Features::StepDefinitions.new(options).render
     end

data/lib/aws-sdk-code-generator/plugin_list.rb

@@ -54,12 +54,14 @@ module AwsSdkCodeGenerator
         'Aws::Plugins::ResponsePaging' => "#{core_plugins}/response_paging.rb",
         'Aws::Plugins::StubResponses' => "#{core_plugins}/stub_responses.rb",
         'Aws::Plugins::IdempotencyToken' => "#{core_plugins}/idempotency_token.rb",
+        'Aws::Plugins::InvocationId' => "#{core_plugins}/invocation_id.rb",
         'Aws::Plugins::JsonvalueConverter' => "#{core_plugins}/jsonvalue_converter.rb",
         'Aws::Plugins::ClientMetricsPlugin' => "#{core_plugins}/client_metrics_plugin.rb",
         'Aws::Plugins::ClientMetricsSendPlugin' => "#{core_plugins}/client_metrics_send_plugin.rb",
         'Aws::Plugins::TransferEncoding' => "#{core_plugins}/transfer_encoding.rb",
         'Aws::Plugins::HttpChecksum' => "#{core_plugins}/http_checksum.rb",
         'Aws::Plugins::ChecksumAlgorithm' => "#{core_plugins}/checksum_algorithm.rb",
+        'Aws::Plugins::RequestCompression' => "#{core_plugins}/request_compression.rb",
         'Aws::Plugins::DefaultsMode' => "#{core_plugins}/defaults_mode.rb",
         'Aws::Plugins::RecursionDetection' => "#{core_plugins}/recursion_detection.rb"
       }
@@ -74,7 +76,6 @@ module AwsSdkCodeGenerator
       plugins.delete('Aws::Plugins::ClientMetricsPlugin')
       plugins.delete('Aws::Plugins::ClientMetricsSendPlugin')
       plugins.delete('Aws::Plugins::TransferEncoding')
-      plugins['Aws::Plugins::InvocationId'] = "#{core_plugins}/invocation_id.rb"
       plugins
     end
 

data/lib/aws-sdk-code-generator/rbs/error_list.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ErrorList
+      include Enumerable
+
+      def initialize(api:, module_name:)
+        @api = api
+        @module_name = module_name
+        @errors = @api['shapes'].inject([]) do |es, (name, shape)|
+          if error_struct?(shape)
+            members = shape["members"].map do |member_name, member_body|
+              MethodSignature.new(
+                method_name: Underscore.underscore(member_name),
+                overloads: ["() -> #{Docstring.ucfirst(member_body['type'] ||'::String')}"]
+              )
+            end
+            es << {
+              name: name,
+              members: members,
+            }
+          end
+          es
+        end
+      end
+
+      def error_struct?(shape)
+        shape['type'] == 'structure' && !!!shape['event'] &&
+          (shape['error'] || shape['exception'])
+      end
+
+      def to_a
+        @errors
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/rbs/keyword_argument_builder.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    # similar to SyntaxExampleHash
+    class KeywordArgumentBuilder
+      include Helper
+
+      attr_reader :newline
+
+      def initialize(api:, shape:, newline:)
+        @api = api
+        @shape = shape
+        @newline = newline
+      end
+
+      def format(indent: '')
+        members_str = struct_members(@shape, indent, [], keyword: true)
+        result = []
+        result << '' if newline
+        result << members_str if !members_str.empty?
+        result << indent if newline
+        result.join(joint)
+      end
+
+      def struct(struct_shape, i, visited)
+        members_str = struct_members(struct_shape, i, visited, keyword: false)
+        result = ["{"]
+        result << members_str if struct_shape['members']&.empty?&.!
+        result << "#{i}}"
+        result.join(joint)
+      end
+
+      def struct_members(struct_shape, i, visited, keyword:)
+        lines = []
+        unless struct_shape['members'].nil?
+          n = 0
+          struct_shape['members'].each do |member_name, member_ref|
+            next if member_ref['documented'] === false
+            more_indent = newline ? "  " : ""
+            if @api['shapes'][member_ref['shape']]['eventstream'] === true
+              # FIXME: "input_event_stream_hander: EventStreams::#{member_ref['shape']}.new"
+              lines << "#{i}#{more_indent}input_event_stream_hander: untyped,"
+            else
+              lines << "#{i}#{more_indent}#{struct_member(struct_shape, member_name, member_ref, i, visited, keyword: keyword)}"
+            end
+          end
+        end
+        if lines.empty?
+          ""
+        else
+          lines.join(joint).chomp(",")
+        end
+      end
+
+      def struct_member(struct, member_name, member_ref, i, visited, keyword:)
+        required = (struct['required'] || []).include?(member_name)
+        if keyword
+          "#{required ? '' : '?'}#{underscore(member_name)}: #{ref_value(member_ref, i + more_indent, visited)},"
+        else
+          "#{underscore(member_name)}: #{ref_value(member_ref, i + more_indent, visited)}#{required ? '' : '?'},"
+        end
+      end
+
+      def ref_value(ref, i, visited)
+        if visited.include?(ref['shape'])
+          return "untyped"
+        else
+          visited  = visited + [ref['shape']]
+        end
+
+        s = shape(ref)
+        case s['type']
+        when 'structure'
+          if ref['shape'] == 'AttributeValue'
+            'untyped'
+          else
+            struct(s, i, visited)
+          end
+        when 'blob'
+          if ref['streaming']
+            "::String | ::StringIO | ::File" # input only
+          else
+            "::String"
+          end
+        when 'list' then list(s, i, visited)
+        when 'map' then map(s, i, visited)
+        when 'boolean' then "bool"
+        when 'integer', 'long' then '::Integer'
+        when 'float', 'double' then '::Float'
+        when 'byte' then '::Integer'
+        when 'character' then '::String'
+        when 'string' then string(ref)
+        when 'timestamp' then '::Time'
+        else raise "unsupported shape #{s['type'].inspect}"
+        end
+      end
+
+      def list(list_shape, i, visited)
+        member_ref = list_shape['member']
+        if complex?(member_ref)
+          complex_list(member_ref, i, visited)
+        else
+          scalar_list(member_ref, i, visited)
+        end
+      end
+
+      def scalar_list(member_ref, i, visited)
+        "Array[#{ref_value(member_ref, i, visited)}]"
+      end
+
+      def complex_list(member_ref, i, visited)
+        newline_indent = newline ? "\n#{i}" : ""
+        "Array[#{newline_indent}#{more_indent}#{ref_value(member_ref, i + more_indent, visited)},#{newline_indent}]"
+      end
+
+      def complex?(ref)
+        s = shape(ref)
+        if s['type'] == 'structure'
+          !ddb_av?(ref)
+        else
+          s['type'] == 'list' || s['type'] == 'map'
+        end
+      end
+
+      def ddb_av?(ref)
+        s = shape(ref)
+        case s['type']
+        when 'list' then ddb_av?(s['member'])
+        when 'structure' then ref['shape'] == 'AttributeValue'
+        else false
+        end
+      end
+
+      def map(map_shape, i, visited)
+        key = string(map_shape['key'])
+        value = ref_value(map_shape['value'], i + more_indent, visited)
+        "Hash[#{key}, #{value}]"
+      end
+
+      def string(ref)
+        string_shape = shape(ref)
+        if string_shape['enum']
+          "(#{string_shape['enum'].map { |s| "\"#{s}\"" }.join(" | ")})"
+        else ref['shape']
+          "::String"
+        end
+      end
+
+      def more_indent
+        newline ? "  " : ""
+      end
+
+      def joint
+        newline ? "\n" : " "
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/rbs/method_signature.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class MethodSignature < Struct.new(:method_name, :overloads, keyword_init: true)
+      def signature
+        "def #{method_name}: #{overloads.join("\n          #{" " * method_name.length}| ")}"
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/rbs/resource_action.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceAction
+      class << self
+        def build_method_signature_list(resource:, api:)
+          (resource["actions"] || []).map do |action_name, action|
+            new(action_name: action_name, action: action, api: api).build_method_signature
+          end
+        end
+      end
+
+      def initialize(action_name:, action:, api:)
+        request = action["request"]
+        operation = api["operations"][request["operation"]]
+        returns = if action["resource"]
+          resource = action["resource"]
+          AwsSdkCodeGenerator::Api.plural?(resource) ? "#{resource["type"]}::Collection" : resource["type"]
+        elsif operation["output"]
+          "Types::#{operation["output"]["shape"]}"
+        else
+          "::Aws::EmptyStructure"
+        end
+
+        @client_request = ResourceClientRequest.new(
+          method_name: Underscore.underscore(action_name),
+          api: api,
+          request: request,
+          returns: returns,
+        )
+      end
+
+      def build_method_signature
+        @client_request.build_method_signature
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/rbs/resource_association.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceAssociation
+      class << self
+        def build_method_signature_list(resource:, api:, paginators:)
+          associations = []
+          associations += has_associations(resource: resource)
+          associations += has_many_associations(resource: resource, api: api, paginators: paginators)
+          associations.sort_by(&:method_name)
+        end
+
+        private
+
+        def has_associations(resource:)
+          resource.fetch("has", {}).map do |name, assoc|
+            method_name = Underscore.underscore(name)
+            arguments = AwsSdkCodeGenerator::ResourceHasAssociation.send(:compute_params, assoc).map { |param|
+              "#{param[:type]} #{Underscore.underscore(param[:name])}"
+            }.join(', ')
+            returns = AwsSdkCodeGenerator::ResourceHasAssociation.send(:return_type, assoc).sub(/, nil$/, "?")
+            MethodSignature.new(
+              method_name: method_name,
+              overloads: ["(#{arguments}) -> #{returns}"]
+            )
+          end
+        end
+
+        def has_many_associations(resource:, api:, paginators:)
+          resource.fetch("hasMany", {}).map do |name, assoc|
+            ResourceClientRequest.new(
+              method_name: Underscore.underscore(name),
+              api: api,
+              request: assoc["request"],
+              returns: "#{assoc["resource"]["type"]}::Collection",
+              skip: AwsSdkCodeGenerator::ResourceHasManyAssociation.send(
+                :paging_options,
+                {
+                  assoc: assoc,
+                  paginators: paginators
+                }
+              ),
+            ).build_method_signature
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/rbs/resource_batch_action.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceBatchAction
+      class << self
+        def build_method_signature_list(resource:, api:)
+          resource.fetch("batchActions", {}).map do |name, action|
+            new(api: api, name: name, action: action).build_method_signature
+          end
+        end
+      end
+
+      def initialize(api:, name:, action:)
+        @api = api
+        @name = name
+        @action = action
+        @batch_action_documentation = AwsSdkCodeGenerator::ResourceBatchActionDocumentation.new(
+          var_name: nil,
+          method_name: method_name,
+          action: action,
+          api: api,
+        )
+        @skip_params = @batch_action_documentation.send(:skip_params)
+        @input_ref = @batch_action_documentation.send(:input_ref)
+        @input_shape = AwsSdkCodeGenerator::Api.shape(@input_ref, api)
+      end
+
+      def build_method_signature
+        arguments = nil
+        include_required = false
+
+        if @input_shape
+          shape = Helper.deep_copy(@input_shape)
+          shape.fetch("members").reject! { |member_name, _| @skip_params.include?(member_name) }
+          arguments = KeywordArgumentBuilder.new(
+            api: @api,
+            shape: shape,
+            newline: true
+          ).format(indent: ' ' * (14 + method_name.length))
+        end
+
+        MethodSignature.new(
+          method_name: method_name,
+          overloads: [
+            "(#{arguments}) -> void",
+            "(#{include_required ? "" : "?"}Hash[Symbol, untyped]) -> void",
+          ]
+        )
+      end
+
+      private
+
+      def method_name
+        AwsSdkCodeGenerator::ResourceBatchAction.send(:build_method_name, @name, @action)
+      end
+    end
+  end
+end