aws-sdk-code-generator 0.2.0.pre → 0.2.1.pre

data/templates/code.mustache

@@ -0,0 +1,4 @@
+{{#code}}
+{{#lines}}
+{{{.}}}{{/lines}}
+{{/code}}

data/templates/documentation.mustache

@@ -0,0 +1,4 @@
+{{#documentation}}
+{{#lines}}
+{{{.}}}{{/lines}}
+{{/documentation}}

data/templates/errors_module.mustache

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+module {{module_name}}
+
+  # When {{service_name}} returns an error response, the Ruby SDK constructs and raises an error.
+  # These errors all extend {{module_name}}::Errors::ServiceError < {Aws::Errors::ServiceError}
+  #
+  # You can rescue all {{service_name}} errors using ServiceError:
+  #
+  #     begin
+  #       # do stuff
+  #     rescue {{module_name}}::Errors::ServiceError
+  #       # rescues all {{service_name}} API errors
+  #     end
+  #
+  #
+  # ## Request Context
+  # ServiceError objects have a {Aws::Errors::ServiceError#context #context} method that returns
+  # information about the request that generated the error.
+  # See {Seahorse::Client::RequestContext} for more information.
+  #
+  # ## Error Classes
+  {{#errors}}
+  {{=<% %>=}}
+  # * {<% name %>}
+  <%={{ }}=%>
+  {{/errors}}
+  #
+  # Additionally, error classes are dynamically generated for service errors based on the error code
+  # if they are not defined above.
+  module Errors
+
+    extend Aws::Errors::DynamicErrors
+
+    {{#errors}}
+    class {{name}} < ServiceError
+
+      # @param [Seahorse::Client::RequestContext] context
+      # @param [String] message
+      # @param [{{data_type}}] data
+      def initialize(context, message, data = Aws::EmptyStructure.new)
+        super(context, message, data)
+      end
+      {{#members}}
+
+      # @return [{{type}}]
+      def {{name}}
+        {{#shared}}@{{name}} || {{/shared}}@data[:{{name}}]
+      end
+      {{/members}}
+      {{#retryable}}
+
+      def retryable?
+        true
+      end
+      {{/retryable}}
+      {{#throttling}}
+
+      def throttling?
+        true
+      end
+      {{/throttling}}
+    end
+
+    {{/errors}}
+  end
+end

data/templates/event_streams_module.mustache

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+module {{module_name}}
+  module EventStreams
+    {{#input_eventstreams}}
+    class {{class_name}}
+
+      def initialize
+        @event_emitter = Aws::EventEmitter.new
+      end
+
+      {{#event_entries}}
+      {{param_hash}}
+      def signal_{{name}}_event(params = {})
+        @event_emitter.emit(:{{name}}, params)
+      end
+
+      {{/event_entries}}
+      def signal_end_stream
+        @event_emitter.emit(:end_stream, {})
+      end
+
+      # @api private
+      # @return Aws::EventEmitter
+      attr_reader :event_emitter
+
+    end
+
+    {{/input_eventstreams}}
+    {{#output_eventstreams}}
+    class {{class_name}}
+
+      def initialize
+        @event_emitter = Aws::EventEmitter.new
+      end
+
+      {{#types}}
+      def on_{{.}}_event(&block)
+        @event_emitter.on(:{{.}}, block) if block_given?
+      end
+
+      {{/types}}
+      def on_error_event(&block)
+        @event_emitter.on(:error, block) if block_given?
+      end
+
+      def on_initial_response_event(&block)
+        @event_emitter.on(:initial_response, block) if block_given?
+      end
+
+      def on_unknown_event(&block)
+        @event_emitter.on(:unknown_event, block) if block_given?
+      end
+
+      def on_event(&block)
+        {{#types}}
+        on_{{.}}_event(&block)
+        {{/types}}
+        on_error_event(&block)
+        on_initial_response_event(&block)
+        on_unknown_event(&block)
+      end
+
+      # @api private
+      # @return Aws::EventEmitter
+      attr_reader :event_emitter
+
+    end
+    {{/output_eventstreams}}
+
+  end
+end
+

data/templates/features/env.mustache

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+$:.unshift(File.expand_path('../../lib', __FILE__))
+$:.unshift(File.expand_path('../../../aws-sdk-core/features', __FILE__))
+{{#gem_dependencies}}
+$:.unshift(File.expand_path('../../../{{dependency}}/lib', __FILE__))
+{{/gem_dependencies}}
+
+require 'features_helper'
+require '{{gem_name}}'
+
+{{module_name}}::Client.add_plugin(ApiCallTracker)

data/templates/features/smoke.mustache

@@ -0,0 +1,17 @@
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+Feature: Smoke tests for {{service}}
+
+Background:
+  Given I create a client in region '{{client_region}}'
+{{#smoke_tests}}
+
+  {{smoke_test_tags}}
+  Scenario: {{scenario_string}}
+  When I call the operation '{{operation}}' with params:
+    """
+{{&param_hash}}
+    """
+  Then {{error_expectation}}
+{{/smoke_tests}}

data/templates/features/smoke_step_definitions.mustache

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+# Shared Smoke Test Definitions
+Given(/I create a client in region '(.*?)'/) do |region|
+  @regional_client = {{module_name}}::Client.new(region: region)
+end
+
+When(/I call the operation '(.*?)' with params:/) do |operation, params|
+  opts = JSON.parse(params, symbolize_names: true)
+  begin
+    @regional_client.send(operation.to_sym, opts)
+    @operation_raised_error = false
+  rescue StandardError
+    @operation_raised_error = true
+  end
+end
+
+Then(/I expect an error was raised/) do
+  expect(@operation_raised_error).to be_truthy
+end
+
+Then(/I expect an error was not raised/) do
+  expect(@operation_raised_error).not_to be_truthy
+end

data/templates/features/step_definitions.mustache

@@ -0,0 +1,8 @@
+Before("@{{var_name}}") do
+  @service = {{module_name}}::Resource.new
+  @client = @service.client
+end
+
+After("@{{var_name}}") do
+  # shared cleanup logic
+end

data/templates/gemspec.mustache

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+Gem::Specification.new do |spec|
+
+  spec.name          = '{{gem_name}}'
+  spec.version       = File.read(File.expand_path('../VERSION', __FILE__)).strip
+  spec.summary       = '{{summary}}'
+  spec.description   = '{{description}}'
+  spec.author        = '{{author}}'
+  spec.homepage      = '{{homepage}}'
+  spec.license       = 'Apache-2.0'
+  spec.email         = ['{{email}}']
+  spec.require_paths = ['lib']
+  spec.files         = Dir['lib/**/*.rb']
+
+  {{#metadata}}
+  spec.metadata = {
+    'source_code_uri' => '{{code_uri}}',
+    'changelog_uri'   => '{{code_uri}}/CHANGELOG.md'
+  }
+
+  {{/metadata}}
+  {{#dependencies}}
+  spec.add_dependency('{{gem}}', '{{&version}}')
+  {{/dependencies}}
+
+end

data/templates/method.mustache

@@ -0,0 +1,7 @@
+{{> documentation}}
+def {{method_name}}{{#arguments}}({{{.}}}){{/arguments}}
+  {{> code}}
+end
+{{#alias}}
+alias {{alias}} {{method_name}}
+{{/alias}}

data/templates/resource_class.mustache

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+module {{module_name}}
+
+  class {{class_name}}
+
+    extend Aws::Deprecations
+
+    # @overload def initialize({{#identifiers}}{{name}}, {{/identifiers}}options = {})
+    {{#identifiers}}
+    #   @param [{{type}}] {{name}}
+    {{/identifiers}}
+    #   @option options [Client] :client
+    {{#identifiers?}}
+    # @overload def initialize(options = {})
+    {{#identifiers}}
+    #   @option options [required, {{type}}] :{{name}}
+    {{/identifiers}}
+    #   @option options [Client] :client
+    {{/identifiers?}}
+    def initialize(*args)
+      options = Hash === args.last ? args.pop.dup : {}
+      {{#identifiers}}
+      @{{name}} = extract_{{name}}(args, options)
+      {{/identifiers}}
+      {{#shape}}
+      @data = options.delete(:data)
+      {{/shape}}
+      {{^shape}}
+      @data = Aws::EmptyStructure.new
+      {{/shape}}
+      @client = options.delete(:client) || Client.new(options)
+      @waiter_block_warned = false
+    end
+
+    # @!group Read-Only Attributes
+    {{#identifiers}}
+
+    # @return [{{type}}]
+    def {{name}}
+      @{{name}}
+    end
+    {{#alias}}
+    alias :{{alias}} :{{name}}
+    {{/alias}}
+    {{/identifiers}}
+    {{#data_attributes}}
+
+    {{> documentation}}
+    def {{name}}
+      data[:{{name}}]
+    end
+    {{/data_attributes}}
+
+    # @!endgroup
+
+    # @return [Client]
+    def client
+      @client
+    end
+
+    {{#load_method}}
+    {{> method}}
+    {{/load_method}}
+    alias :reload :load
+
+    {{#data_method}}
+    {{> method}}
+    {{/data_method}}
+
+    # @return [Boolean]
+    #   Returns `true` if this resource is loaded.  Accessing attributes or
+    #   {#data} on an unloaded resource will trigger a call to {#load}.
+    def data_loaded?
+      !!@data
+    end
+    {{#exists_waiter}}
+
+    # @param [Hash] options ({})
+    # @return [Boolean]
+    #   Returns `true` if the {{class_name}} exists.
+    def exists?(options = {})
+      begin
+        wait_until_exists(options.merge(max_attempts: 1))
+        true
+      rescue Aws::Waiters::Errors::UnexpectedError => e
+        raise e.error
+      rescue Aws::Waiters::Errors::WaiterFailed
+        false
+      end
+    end
+    {{/exists_waiter}}
+    {{#waiters}}
+
+    # @param [Hash] options ({})
+    # @option options [Integer] :max_attempts ({{max_attempts}})
+    # @option options [Float] :delay ({{delay}})
+    # @option options [Proc] :before_attempt
+    # @option options [Proc] :before_wait
+    # @return [{{class_name}}]
+    def wait_until_{{name}}(options = {}, &block)
+      options, params = separate_params_and_options(options)
+      waiter = Waiters::{{waiter_class_name}}.new(options)
+      yield_waiter_and_warn(waiter, &block) if block_given?
+      {{#wait_call}}
+      {{#lines}}
+      {{{.}}}{{/lines}}
+      {{/wait_call}}
+      {{class_name}}.new({
+      {{#constructor_args}}
+      {{#lines}}
+      {{{.}}}{{/lines}}
+      {{/constructor_args}}
+      })
+    end
+    {{/waiters}}
+    {{#wait_until}}
+
+    # @deprecated Use [{{module_name}}::Client] #wait_until instead
+    #
+    # Waiter polls an API operation until a resource enters a desired
+    # state.
+    #
+    # @note The waiting operation is performed on a copy. The original resource
+    #   remains unchanged.
+    #
+    # ## Basic Usage
+    #
+    # Waiter will polls until it is successful, it fails by
+    # entering a terminal state, or until a maximum number of attempts
+    # are made.
+    #
+    #     # polls in a loop until condition is true
+    #     resource.wait_until(options) {|resource| condition}
+    #
+    # ## Example
+    #
+    #     instance.wait_until(max_attempts:10, delay:5) do |instance|
+    #       instance.state.name == 'running'
+    #     end
+    #
+    # ## Configuration
+    #
+    # You can configure the maximum number of polling attempts, and the
+    # delay (in seconds) between each polling attempt. The waiting condition is
+    # set by passing a block to {#wait_until}:
+    #
+    #     # poll for ~25 seconds
+    #     resource.wait_until(max_attempts:5,delay:5) {|resource|...}
+    #
+    # ## Callbacks
+    #
+    # You can be notified before each polling attempt and before each
+    # delay. If you throw `:success` or `:failure` from these callbacks,
+    # it will terminate the waiter.
+    #
+    #     started_at = Time.now
+    #     # poll for 1 hour, instead of a number of attempts
+    #     proc = Proc.new do |attempts, response|
+    #       throw :failure if Time.now - started_at > 3600
+    #     end
+    #
+    #       # disable max attempts
+    #     instance.wait_until(before_wait:proc, max_attempts:nil) {...}
+    #
+    # ## Handling Errors
+    #
+    # When a waiter is successful, it returns the Resource. When a waiter
+    # fails, it raises an error.
+    #
+    #     begin
+    #       resource.wait_until(...)
+    #     rescue Aws::Waiters::Errors::WaiterFailed
+    #       # resource did not enter the desired state in time
+    #     end
+    #
+    # @yieldparam [Resource] resource to be used in the waiting condition.
+    #
+    # @raise [Aws::Waiters::Errors::FailureStateError] Raised when the waiter
+    #   terminates because the waiter has entered a state that it will not
+    #   transition out of, preventing success.
+    #
+    #   yet successful.
+    #
+    # @raise [Aws::Waiters::Errors::UnexpectedError] Raised when an error is
+    #   encountered while polling for a resource that is not expected.
+    #
+    # @raise [NotImplementedError] Raised when the resource does not
+    #
+    # @option options [Integer] :max_attempts (10) Maximum number of
+    # attempts
+    # @option options [Integer] :delay (10) Delay between each
+    # attempt in seconds
+    # @option options [Proc] :before_attempt (nil) Callback
+    # invoked before each attempt
+    # @option options [Proc] :before_wait (nil) Callback
+    # invoked before each wait
+    # @return [Resource] if the waiter was successful
+    def wait_until(options = {}, &block)
+      self_copy = self.dup
+      attempts = 0
+      options[:max_attempts] = 10 unless options.key?(:max_attempts)
+      options[:delay] ||= 10
+      options[:poller] = Proc.new do
+        attempts += 1
+        if block.call(self_copy)
+          [:success, self_copy]
+        else
+          self_copy.reload unless attempts == options[:max_attempts]
+          :retry
+        end
+      end
+      Aws::Waiters::Waiter.new(options).wait({})
+    end
+    {{/wait_until}}
+    {{#actions?}}
+
+    # @!group Actions
+    {{#actions}}
+
+    {{> method}}
+    {{/actions}}
+    {{/actions?}}
+    {{#associations?}}
+
+    # @!group Associations
+    {{#associations}}
+
+    {{> method}}
+    {{/associations}}
+    {{/associations?}}
+
+    {{#identifiers_method}}
+    {{> method}}
+    {{/identifiers_method}}
+    deprecated(:identifiers)
+    {{#identifiers?}}
+
+    private
+    {{#identifiers}}
+
+    def extract_{{name}}(args, options)
+      value = args[{{offset}}] || options.delete(:{{name}})
+      case value
+      when {{type}} then value
+      when nil then raise ArgumentError, "missing required option :{{name}}"
+      else
+        msg = "expected :{{name}} to be a {{type}}, got #{value.class}"
+        raise ArgumentError, msg
+      end
+    end
+    {{/identifiers}}
+    {{/identifiers?}}
+    {{#waiters?}}
+
+    def yield_waiter_and_warn(waiter, &block)
+      if !@waiter_block_warned
+        msg = "pass options to configure the waiter; "\
+              "yielding the waiter is deprecated"
+        warn(msg)
+        @waiter_block_warned = true
+      end
+      yield(waiter.waiter)
+    end
+
+    def separate_params_and_options(options)
+      opts = Set.new(
+        [:client, :max_attempts, :delay, :before_attempt, :before_wait]
+      )
+      waiter_opts = {}
+      waiter_params = {}
+      options.each_pair do |key, value|
+        if opts.include?(key)
+          waiter_opts[key] = value
+        else
+          waiter_params[key] = value
+        end
+      end
+      waiter_opts[:client] ||= @client
+      [waiter_opts, waiter_params]
+    end
+    {{/waiters?}}
+
+    {{^batch_actions?}}
+    class Collection < Aws::Resources::Collection; end
+    {{/batch_actions?}}
+    {{#batch_actions?}}
+    class Collection < Aws::Resources::Collection
+
+      # @!group Batch Actions
+      {{#batch_actions}}
+
+      {{> method}}
+      {{/batch_actions}}
+
+      # @!endgroup
+
+    end
+    {{/batch_actions?}}
+  end
+end