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

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

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  class SyntaxExampleHash
+
+    include Helper
+
+    # @option options [required, Hash] :api
+    # @option options [required, Hash] :shape_ref
+    def initialize(options = {})
+      @api = options.fetch(:api)
+      @shape = options.fetch(:shape)
+      @async = options[:async] || false
+    end
+
+    def format(indent = '')
+      struct(@shape, indent, [])
+    end
+
+    private
+
+    def ref_value(ref, i, visited)
+      if visited.include?(ref['shape'])
+        return "{\n#{i}  # recursive #{ref['shape']}\n#{i}}"
+      else
+        visited  = visited + [ref['shape']]
+      end
+
+      s = shape(ref)
+      case s['type']
+      when 'structure'
+        if ref['shape'] == 'AttributeValue'
+          '"value"'
+        else
+          struct(s, i, visited)
+        end
+
+      when 'blob'
+        if ref['streaming']
+          'source_file'
+        else
+          '"data"'
+        end
+
+      when 'list' then list(s, i, visited)
+      when 'map' then map(s, i, visited)
+      when 'boolean' then "false"
+      when 'integer', 'long' then '1'
+      when 'float', 'double' then '1.0'
+      when 'byte' then '97'
+      when 'character' then '"a"'
+      when 'string' then string(ref)
+      when 'timestamp' then 'Time.now'
+      else raise "unsupported shape #{s['type'].inspect}"
+      end
+    end
+
+    def struct(struct_shape, i, visited)
+      lines = ['{']
+      unless struct_shape['members'].nil?
+        struct_shape['members'].each_pair do |member_name, member_ref|
+          next if member_ref['documented'] === false
+          # input eventstream shouldn't be provided from params
+          if @api['shapes'][member_ref['shape']]['eventstream'] === true
+            lines << "#{i}  input_event_stream_hander: EventStreams::#{member_ref['shape']}.new,"
+          else
+            lines << struct_member(struct_shape, member_name, member_ref, i, visited)
+          end
+        end
+      end
+      lines << "#{i}}"
+      lines.join("\n")
+    end
+
+    def struct_member(struct, member_name, member_ref, i, visited)
+      entry = "#{i}  #{underscore(member_name)}: #{ref_value(member_ref, i + '  ', visited)},"
+      required = (struct['required'] || []).include?(member_name)
+      apply_comments(member_ref, entry, required: required)
+    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)
+      "[#{ref_value(member_ref, i, visited)}]"
+    end
+
+    def complex_list(member_ref, i, visited)
+      "[\n#{i}  #{ref_value(member_ref, i + '  ', visited)},\n#{i}]"
+    end
+
+    def map(map_shape, i, visited)
+      key = string(map_shape['key'])
+      value = ref_value(map_shape['value'], i + '  ', visited)
+      "{\n#{i}  #{key} => #{value},#{comments(map_shape['value'], false)}\n#{i}}"
+    end
+
+    def string(ref)
+      string_shape = shape(ref)
+      if string_shape['enum']
+        string_shape['enum'].first.inspect
+      else ref['shape']
+        ref['shape'].inspect
+      end
+    end
+
+    def apply_comments(ref, text, options = {})
+      required = options.fetch(:required)
+      lines = text.lines.to_a
+      if lines[0].match(/\n$/)
+        lines[0] = lines[0].sub(/\n$/, comments(ref, required) + "\n")
+      else
+        lines[0] += comments(ref, required)
+      end
+      lines.join
+    end
+
+    def comments(ref, required)
+      comments = []
+      if ref[:response_target]
+        comments << 'where to write response data, file path, or IO object'
+      end
+      if ref[:streaming]
+        comments << 'file/IO object, or string data'
+      end
+      if required
+        comments << 'required'
+      end
+      if enum = enum_values(ref)
+        comments << "accepts #{enum.to_a.join(', ')}"
+      end
+      if ddb_av?(ref)
+        comments << 'value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>'
+      end
+      comments == [] ? '' : " # #{comments.join(', ')}"
+    end
+
+    def enum_values(ref)
+      s = shape(ref)
+      case s['type']
+      when 'list' then enum_values(s['member'])
+      when 'string' then s['enum']
+      else nil
+      end
+    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
+
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AwsSdkCodeGenerator
   module Underscore
     class << self
@@ -10,11 +12,12 @@ module AwsSdkCodeGenerator
       # @param [String] string
       # @return [String] Returns the underscored version of the given string.
       def underscore(string)
-        string.
-          gsub(@irregular_regex) { |word| '_' + @irregular_inflections[word] }.
-          gsub(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2').
-          scan(/[a-z0-9]+|\d+|[A-Z0-9]+[a-z]*/).
-          join('_').downcase
+        new_string = string.dup
+        new_string.gsub!(@irregular_regex) { |word| "_#{@irregular_inflections[word]}" }
+        new_string.gsub!(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'.freeze)
+        new_string = new_string.scan(/[a-z0-9]+|\d+|[A-Z0-9]+[a-z]*/).join('_'.freeze)
+        new_string.downcase!
+        new_string
       end
 
       # @param [String<JMESPath>]
@@ -38,6 +41,8 @@ module AwsSdkCodeGenerator
       'iSCSI' => 'iscsi',
       'ACLs' => 'acls',
       'Md5s' => 'md5s',
+      'HIT' => 'hit',
+      'URL' => 'url',
       #'SSEKMS' => 'sse_kms',
     })
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mustache'
 
 module AwsSdkCodeGenerator
@@ -15,9 +17,40 @@ module AwsSdkCodeGenerator
       subclass.raise_on_context_miss = true
     end
 
+    # @param (see Underscore.underscore)
+    # @option (see Underscore.underscore)
+    # @return (see Underscore.underscore)
     def underscore(string)
       Underscore.underscore(string)
     end
 
+    # @param (see Underscore.underscore_jmespath)
+    # @option (see Underscore.underscore_jmespath)
+    # @return (see Underscore.underscore_jmespath)
+    def underscore_jmespath(string)
+      Underscore.underscore_jmespath(string)
+    end
+
+    # @param (see Docstring.html_to_markdown)
+    # @option (see Docstring.html_to_markdown)
+    # @return (see Docstring.html_to_markdown)
+    def html_to_markdown(html, options = {})
+      Docstring.html_to_markdown(html, options)
+    end
+
+    # @param (see Docstring.block_comment)
+    # @option (see Docstring.block_comment)
+    # @return (see Docstring.block_comment)
+    def block_comment(text, options = {})
+      Docstring.block_comment(text, options = {})
+    end
+
+    # @param (see Docstring.join_docstrings)
+    # @option (see Docstring.join_docstrings)
+    # @return (see Docstring.join_docstrings)
+    def join_docstrings(docs, options = {})
+      Docstring.join_docstrings(docs, options)
+    end
+
   end
 end

data/lib/aws-sdk-code-generator/views/apig_endpoint_class.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+
+    class APIGEndpointClass < View
+
+      # @option options [required, String] :module_name
+      # @option options [required, String] :default_endpoint
+      def initialize(options)
+        @module_name = options.fetch(:module_name)
+        endpoint = options.fetch(:default_endpoint)
+        unless endpoint.start_with?('http://') || endpoint.start_with?('https://')
+          endpoint = "https://#{endpoint}"
+        end
+        @default_endpoint = endpoint
+      end
+
+      attr_reader :module_name
+
+      attr_reader :default_endpoint
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/apig_readme.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class APIGReadme < View
+
+      # @option options [required, String] :service_name
+      # @option options [required, String] :module_name
+      # @option options [required, String] :gem_name
+      # @option options [required, String] :gem_major_version
+      def initialize(options)
+        @service_name = options.fetch(:service_name)
+        @module_name = options.fetch(:module_name)
+        @gem_name = options.fetch(:gem_name)
+        @gem_major_version = options.fetch(:gem_major_version)
+      end
+
+      # @return [String]
+      attr_reader :module_name
+
+      # @return [String]
+      attr_reader :gem_major_version
+
+      # @return [String]
+      attr_reader :gem_name
+
+      # @return [String]
+      attr_reader :service_name
+
+    end
+  end
+end