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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceMethod
+
+    # @return [String]
+    attr_accessor :method_name
+
+    # @return [String, nil]
+    attr_accessor :arguments
+
+    # @return [String]
+    attr_accessor :code
+
+    # @return [String, nil]
+    attr_accessor :documentation
+
+    # @return [String, nil]
+    attr_accessor :alias
+
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceSkipParams
+    class << self
+
+      def compute(shape, request)
+        if shape
+          shape['members'].inject([]) do |skip, (member_name, member_ref)|
+            skip << member_name if request_param?(member_name, request)
+            skip
+          end
+        else
+          []
+        end
+      end
+
+      private
+
+      def request_param?(member_name, request)
+        request.fetch('params', []).any? do |param|
+          if
+            param['target'].match(/^#{member_name}\b/) &&
+            !(param['target'].include?('[') &&
+            param['target'].include?('.'))
+          then
+            true
+          else
+            false
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceValueSource < String
+
+    def initialize(value)
+      super(send("param_#{underscore(value['source'])}", value))
+    end
+
+    private
+
+    def param_identifier(param)
+      "@" + underscore(param['name'])
+    end
+
+    def param_data(param)
+      path = param['path']
+      if path == '@'
+        'data'
+      elsif path.match(/^(\w(\[0\])?)+(\.\w+)*$/)
+        data_path = underscore_path(path).gsub(/\w+/) { |word| "[:#{word}]" }
+        # In case resource model path contains x.[:0].y
+        'data' + data_path.gsub(/\[\[\:/, '[').gsub(/\]\]/, ']').gsub(/\./, '')
+      else
+        raise "unsupported path: #{path.inspect}"
+      end
+    end
+
+    def param_response(param)
+      if param['path'] == '@'
+        'resp.data'
+      else
+        'resp.data.' + underscore_path(param['path'].gsub(/\[\]/, "[0]"))
+      end
+    end
+
+    def param_request_parameter(param)
+      if param['path'].match(/^\w+(\.\w+)*$/)
+        "options" + path_parts(param['path']).map { |part| "[:#{part}]" }.join
+      else
+        raise "unsupported path expression: #{param['path']}"
+      end
+    end
+
+    def param_string(param)
+      param['value'].inspect
+    end
+    alias param_integer param_string
+    alias param_boolean param_string
+
+    def param_input(param)
+      underscore(param['target'])
+    end
+
+    def underscore(str)
+      Underscore.underscore(str)
+    end
+
+    def underscore_path(path)
+      path.gsub(/\w+/) { |part| underscore(part) }
+    end
+
+    def path_parts(path)
+      path.split('.').map { |part| underscore(part) }
+    end
+
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceWaiter
+
+    # @return [String]
+    attr_accessor :name
+
+    attr_accessor :client_waiter_name
+
+    # @return [String]
+    attr_accessor :waiter_class_name
+
+    # @return [Integer]
+    attr_accessor :delay
+
+    # @return [Integer]
+    attr_accessor :max_attempts
+
+    # @return [String<Ruby>]
+    attr_accessor :wait_call
+
+    # @return [String<Ruby>]
+    attr_accessor :constructor_args
+
+    class << self
+
+      # @param [Hash] resource
+      # @param [Hash, nil] client_waiters
+      # @return [Array<ResourceWaiter>]
+      def build_list(resource, client_waiters)
+        client_waiters = Waiter.build_list(client_waiters)
+        (resource['waiters'] || {}).map do |name, waiter|
+          client_waiter = client_waiters.find do |w|
+            w.name == Underscore.underscore(waiter['waiterName'])
+          end
+          ResourceWaiter.new.tap do |w|
+            w.name = Underscore.underscore(name)
+            w.client_waiter_name = client_waiter.name
+            w.waiter_class_name = client_waiter.class_name
+            w.delay = client_waiter.delay
+            w.max_attempts = client_waiter.max_attempts
+            w.wait_call = wait_call(waiter)
+            w.constructor_args = constructor_args(resource, waiter)
+          end
+        end
+      end
+
+      private
+
+      def wait_call(waiter)
+        args = ResourceClientRequestParams.new(
+          params: waiter['params']
+        ).to_s.strip
+        if waiter['path']
+          "resp = waiter.wait(params.merge(#{args}))"
+        else
+          "waiter.wait(params.merge(#{args}))"
+        end
+      end
+
+      def constructor_args(resource, waiter)
+        args = {}
+        (resource['identifiers'] || []).each do |i|
+          name = Underscore.underscore(i['name']).to_sym
+          args[name] = "@#{name}"
+        end
+        if waiter['path']
+          args[:data] = ResourceValueSource.new(
+            'source' => 'response',
+            'path' => waiter['path']
+          )
+        end
+        args[:client] = '@client'
+        HashFormatter.new(wrap: false).format(args)[1..-2]
+      end
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AwsSdkCodeGenerator
   class Service
 
@@ -12,6 +14,7 @@ module AwsSdkCodeGenerator
     # @option options [Hash, String] :waiters
     # @option options [Hash, String] :resources
     # @option options [Hash, String] :examples
+    # @option options [Hash, String] :smoke_tests
     # @option options [Hash<gem,version>] :gem_dependencies ({})
     # @option options [Hash] :add_plugins ({})
     # @option options [Hash] :remove_plugins ([])
@@ -22,24 +25,32 @@ module AwsSdkCodeGenerator
       @gem_name = options[:gem_name] || "aws-sdk-#{identifier}"
       @gem_version = options.fetch(:gem_version)
       @api = load_json(options.fetch(:api))
-      ApplyDocs.new(@api).apply(load_json(options[:docs]))
+      unless @api['metadata']['protocol'] == 'api-gateway'
+        # Dont reply on API Gateway doc.json
+        ApplyDocs.new(@api).apply(load_json(options[:docs]))
+      end
       @paginators = load_json(options[:paginators])
       @waiters = load_json(options[:waiters])
       @resources = load_json(options[:resources])
       @examples = load_json(options[:examples])
-      @gem_dependencies = {
-        'aws-sdk-core' => '3.0.0.rc1'
-      }.merge(options[:gem_dependencies] || {})
+      @smoke_tests = load_json(options[:smoke_tests])
+      @gem_dependencies = options[:gem_dependencies] || {}
       @add_plugins = options[:add_plugins] || {}
       @remove_plugins = options[:remove_plugins] || []
       @endpoints_key = options.fetch(:endpoints_key, nil)
+      # APIG custom service only
+      @default_endpoint = options[:default_endpoint]
 
       # computed attributes
       @protocol = api.fetch('metadata').fetch('protocol')
+      @protocol_settings = api.fetch('metadata')['protocolSettings'] || {}
       @api_version = api.fetch('metadata')['apiVersion']
       @signature_version = api.fetch('metadata')['signatureVersion']
       @full_name = api.fetch('metadata')['serviceFullName']
       @short_name = api.fetch('metadata')['serviceAbbreviation'] || @full_name
+      @require_endpoint_discovery = api.fetch('operations', []).any? do |_, o|
+        o['endpointdiscovery'] && o['endpointdiscovery']['required']
+      end
     end
 
     # @return [String] The service name, e.g. "S3"
@@ -63,6 +74,9 @@ module AwsSdkCodeGenerator
     # @return [Hash, nil] The service shared examples model.
     attr_reader :examples
 
+    # @return [Hash, nil] The service smoke test model.
+    attr_reader :smoke_tests
+
     # @return [Hash<String,String>] A hash of gem dependencies. Hash keys
     #   are gem names, values are versions.
     attr_reader :gem_dependencies
@@ -70,9 +84,15 @@ module AwsSdkCodeGenerator
     # @return [String]
     attr_reader :gem_version
 
+    # @return [String] The gem name, e.g. "aws-sdk-s3"
+    attr_reader :gem_name
+
     # @return [String, nil]
     attr_reader :endpoints_key
 
+    # @return [String] Required for APIG custom service
+    attr_reader :default_endpoint
+
     # @return [Hash<String,String>] A hash of plugins to add.
     attr_reader :add_plugins
 
@@ -82,12 +102,12 @@ module AwsSdkCodeGenerator
     # @return [String] The service identifier, e.g. "s3"
     attr_reader :identifier
 
-    # @return [String] The gem name, e.g. "aws-sdk-s3"
-    attr_reader :gem_name
-
     # @return [String] The service protocol, e.g. "json", "query", etc.
     attr_reader :protocol
 
+    # @return [Hash] The service protocol settings
+    attr_reader :protocol_settings
+
     # @return [String] The service API version, e.g. "YYYY-MM-DD".
     attr_reader :api_version
 
@@ -101,6 +121,9 @@ module AwsSdkCodeGenerator
     # @return [String] The short product name for the service, e.g. "Amazon S3".
     attr_reader :short_name
 
+    # @return [Boolean] true if any operation requires endpoint_discovery
+    attr_reader :require_endpoint_discovery
+
     # @api private
     def inspect
       "#<#{self.class.name}>"

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class SharedExample
+
+    def initialize(params, method_name, operation, api, comments)
+      @params = params
+      @method_name = method_name
+      @operation = operation
+      @api = api
+      @comments = comments
+      @params ||= {}
+    end
+
+    def to_str_input
+      lines = structure(@params, Api.shape(@operation['input'], @api), "", [])
+      params = lines.join("\n")
+      "resp = client.#{@method_name}(#{params})"
+    end
+
+    def to_str_output
+      lines = structure(@params, Api.shape(@operation['output'], @api), "", [])
+      params = lines.join("\n")
+      "#{params}"
+    end
+
+    private
+
+    def entry(json, ref, indent, path)
+      case ref['type']
+      when 'structure'
+        if is_ddb_simple_attribute?(ref)
+          string(json.first[1])
+        else
+          structure(json, ref, indent, path)
+        end
+      when 'map' then map(json, ref, indent, path)
+      when 'list' then list(json, ref, indent, path)
+      when 'timestamp' then "Time.parse(#{json.inspect})"
+      when 'string', 'blob' then string(json)
+      else json
+      end
+    end
+
+    def is_ddb_simple_attribute?(ref)
+      ref['members'].keys == ["S", "N", "B", "SS", "NS", "BS", "M", "L", "NULL", "BOOL"] &&
+        @api['metadata']['serviceFullName'] == 'Amazon DynamoDB'
+    end
+
+    def string(json)
+      # Travis jruby hangs when parsing long string (e.g. policy string)
+      # Clean all white spaces in those strings
+      if json.length > 2048
+        json.gsub(/\s+/, "").inspect
+      else
+        json.inspect
+      end
+    end
+
+    def structure(json, ref, indent, path)
+      lines = ["{"]
+      json.each do |key, val|
+        path << ".#{key}"
+        shape_val = entry(val, Api.shape(ref['members'][key], @api), "#{indent}  ", path)
+        lines << "#{indent}  #{Underscore.underscore(key)}: #{format(shape_val)}, #{apply_comments(path)}"
+        path.pop
+      end
+      lines << "#{indent}}"
+      lines
+    end
+
+    def map(json, ref, indent, path)
+      lines = ["{"]
+      json.each do |key, val|
+        path << ".#{key}"
+        _, ref_value = Api.resolve(ref['value'], @api)
+        shape_val = entry(val, ref_value, "#{indent}  ", path)
+        lines << "#{indent}  \"#{key}\" => #{format(shape_val)}, #{apply_comments(path)}"
+        path.pop
+      end
+      lines << "#{indent}}"
+      lines
+    end
+
+    def list(json, ref, indent, path)
+      lines = ["["]
+      json.each_with_index do |member, index|
+        path << "[#{index}]"
+        _, ref_val = Api.resolve(ref['member']['shape'], @api)
+        shape_val = entry(member, ref_val, "#{indent}  ", path)
+        if shape_val.is_a?(Array)
+          shape_val = shape_val.join("\n")
+        end
+        lines << "#{indent}  #{shape_val}, #{apply_comments(path)}"
+        path.pop
+      end
+      lines << "#{indent}]"
+      lines
+    end
+
+    def format(shape_val)
+      formatted = []
+      if shape_val.is_a?(Array)
+        hashes = []
+        shape_val.each do |v|
+          hashes << (v.is_a?(Hash) ? format_hash(v, '  ') : v)
+        end
+        hashes.join(",")
+        formatted << hashes
+      elsif shape_val.is_a?(Hash)
+        formatted << format_hash(shape_val, '  ')
+      else
+        formatted << shape_val
+      end
+      formatted.join("\n")
+    end
+
+    def format_hash(value, indent)
+      HashFormatter.new(indent: indent).format(value)
+    end
+
+    def apply_comments(path)
+      key = path.join().sub(/^\./, '')
+      if @comments && @comments[key]
+        "# #{@comments[key]}"
+      else
+        ""
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  class SyntaxExample
+
+    include Helper
+
+    # @option options [required, Hash] :api
+    # @option options [required, Hash] :shape
+    def initialize(options = {})
+      @api = options.fetch(:api)
+      @method_name = options.fetch(:method_name)
+      @receiver = options.fetch(:receiver)
+      @resp_var = options[:resp_var] ? "#{options[:resp_var]} = " : ''
+      @shape = filter_shape(options)
+      @async = options[:async] || false
+      @hash = SyntaxExampleHash.new(api: @api, shape: @shape, async: @async).format('#   ') if @shape
+    end
+
+    def format
+      if @shape && @shape['members'] && @shape['members'].length > 0
+        <<-EXAMPLE.strip
+# @example Request syntax with placeholder values
+#
+#   #{@resp_var}#{@receiver}.#{@method_name}(#{@hash})
+#{async_format}
+        EXAMPLE
+      else
+        nil
+      end
+    end
+
+    def async_format
+      if @async
+        <<-ASYNC.strip
+#   # => Seahorse::Client::AsyncResponse
+#   async_resp.wait
+#   # => Seahorse::Client::Response
+#   # Or use async_resp.join!
+        ASYNC
+      else
+        nil
+      end
+    end
+
+    private
+
+    def filter_shape(options)
+      skip = Set.new(options.fetch(:skip, []))
+      shape = Helper.deep_copy(options.fetch(:shape))
+      options.fetch(:skip, []).each do |skip|
+        shape['members'].delete(skip)
+      end
+      shape
+    end
+
+  end
+end