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

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceBatchAction
+    class << self
+
+      # @return [Array<ResourceMethod>]
+      def build_list(resource_name, resource, api)
+        resource.fetch('batchActions', {}).map do |name, action|
+          method_name = build_method_name(name, action)
+          ResourceMethod.new.tap do |m|
+            m.method_name = method_name
+            m.arguments = 'options = {}'
+            m.code = code(action, api)
+            m.documentation = docs(method_name, resource_name, action, api)
+          end
+        end
+      end
+
+      private
+
+      def code(action, api)
+        ResourceBatchActionCode.new(action: action, api: api).build
+      end
+
+      def docs(method_name, resource_name, action, api)
+        ResourceBatchActionDocumentation.new(
+          method_name: method_name,
+          var_name: Underscore.underscore(resource_name),
+          action: action,
+          api: api
+        ).build
+      end
+
+      def build_method_name(name, action)
+        method_name = "batch_" + Underscore.underscore(name)
+        method_name += '!' if dangerous?(name, action)
+        method_name
+      end
+
+      def dangerous?(name, action)
+        if
+          name.match(/delete/i) ||
+          name.match(/terminate/i) ||
+          action['request']['operation'].match(/delete/i) ||
+          action['request']['operation'].match(/terminate/i)
+        then
+          true
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceBatchActionCode
+
+    def initialize(options)
+      @action = options.fetch(:action)
+      @api = options.fetch(:api)
+      compute_params
+    end
+
+    # @return [String]
+    def build
+      parts = []
+      parts << 'batch_enum.each do |batch|'
+      parts << initialize_params
+      parts << apply_params_per_batch
+      parts << "  batch[0].client.#{client_method}(params)"
+      parts << 'end'
+      parts << 'nil'
+      parts.join("\n").rstrip
+    end
+
+    private
+
+    def compute_params
+      @batch_obj = {}
+      @per_batch = {}
+      @action_prefix = false
+      @action['request']['params'].each do |param|
+        if param['target'].include?('[')
+          parts = param['target'].split('[')
+          pair = parts[0].split('.')
+          if pair.length > 1
+            @action_prefix = pair.first
+          end
+          batch_name = pair.last
+          batch_param = underscore(parts[1].sub(/.*?\./, ''))
+          batch_param = batch_param == "" ? underscore(param['name']) : batch_param
+          (@batch_obj[batch_name] ||= []) << {
+            batch_param.to_sym => underscore(param['name'] || param['path'])
+          }
+        else
+          @per_batch[param['target']] = underscore(param['name'])
+        end
+      end
+    end
+
+    def client_method
+      Underscore.underscore(@action['request']['operation'])
+    end
+
+    def initialize_params
+      param_block = []
+      param_block << "  params = Aws::Util.copy_hash(options)"
+      param_block << apply_param_hash
+      param_block.join("\n")
+    end
+
+    def apply_param_hash
+      block = []
+      @per_batch.each do |key, value|
+        block << "  params[:#{underscore(key)}] = batch[0].#{value}"
+      end
+      if @action_prefix
+        action = underscore(@action_prefix)
+        block << "  params[:#{action}] ||= {}"
+        @batch_obj.keys.each do |key|
+          block << "  params[:#{action}][:#{underscore(key)}] ||= []"
+        end
+      else
+        @batch_obj.keys.each {|key| block << "  params[:#{underscore(key)}] ||= []"}
+      end
+      block.join("\n")
+    end
+
+    def apply_params_per_batch
+      each_batch = []
+      each_batch << "  batch.each do |item|"
+      @batch_obj.each do |key, value|
+        hash = {}
+        value.each do |v|
+          param, identifier = v.first
+          hash[param.to_sym] = "item.#{identifier}"
+        end
+        first_line = @action_prefix ? "    params[:#{underscore(@action_prefix)}][:#{underscore(key)}] << "
+          : "    params[:#{underscore(key)}] << "
+        if list_of_string?(key, @action['request']['operation'])
+          _, v = hash.first
+          each_batch << first_line + v
+        else
+          each_batch << first_line + "{"
+          # hashformatter treats this as inline, need extra indent
+          indent_count = hash.size == 1 ? 3 : 2
+          each_batch << indent_helper(HashFormatter.new(wrap: false).format(hash), indent_count)
+          each_batch << "    }"
+        end
+      end
+      each_batch << "  end"
+      each_batch.join("\n")
+    end
+
+    def indent_helper(lines, count)
+      block = []
+      lines.split("\n").each do |line|
+        next if line.strip == ""
+        block << "  " * count + line
+      end
+      block.join("\n")
+    end
+
+    def underscore(str)
+      Underscore.underscore(str)
+    end
+
+    def list_of_string?(member, operation_name)
+      operation_shape = @api['operations'][operation_name]
+      input_shape = @api['shapes'][operation_shape['input']['shape']]
+
+      members = input_shape['type'] == 'structure' ? 'members' : 'member'
+      if @action_prefix
+        prefix_shape_ref = input_shape[members][@action_prefix]
+        _, prefix_shape = Api.resolve(prefix_shape_ref, @api)
+        prefix_members = prefix_shape['type'] == 'structure' ? 'members' : 'member'
+        member_shape_ref = prefix_shape[prefix_members][member]
+      else
+        member_shape_ref = input_shape[members][member]
+      end
+      _, shape = Api.resolve(member_shape_ref, @api)
+      return false unless shape['type'] == 'list'
+      _, item_shape = Api.resolve(shape['member'], @api)
+      item_shape['type'] == 'string'
+    end
+
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceBatchActionDocumentation
+
+    def initialize(options)
+      @var_name = options.fetch(:var_name)
+      @method_name = options.fetch(:method_name)
+      @action = options.fetch(:action)
+      @api = options.fetch(:api)
+      compute_params
+    end
+
+    # @return [String]
+    def build
+      Docstring.join_docstrings([
+        request_syntax_example,
+        '# @param options ({})',
+        option_tags,
+        "# @return [void]",
+      ], block_comment: false, separator: false)
+    end
+
+    private
+
+    def request_syntax_example
+      if input_ref
+        SyntaxExample.new(
+          api: @api,
+          shape: input_shape,
+          method_name: @method_name,
+          receiver: @var_name,
+          resp_var: nil,
+          skip: skip_params
+        ).format
+      end
+    end
+
+    def skip_params
+      skip = []
+      if @action_prefix
+        skip << @action_prefix
+      else
+        skip += @per_batch.keys
+        skip += @batch_obj.keys
+      end
+      skip + ResourceSkipParams.compute(input_shape, @action['request'])
+    end
+
+    def option_tags
+      skip = skip_params
+      if input_shape = Api.shape(input_ref, @api)
+        input_shape['members'].map do |member_name, member_ref|
+          if skip.include?(member_name)
+            nil # skipped
+          else
+            YardOptionTag.new(
+              name: Underscore.underscore(member_name),
+              required: input_shape.fetch('required', []).include?(member_name),
+              ruby_type: Api.ruby_input_type(member_ref, @api),
+              docstring: Docstring.html_to_markdown(Api.docstring(member_ref, @api)),
+            ).to_str
+          end
+        end
+      end
+    end
+
+    def input_ref
+      @api['operations'][@action['request']['operation']]['input']
+    end
+
+    def input_shape
+      Api.shape(input_ref, @api)
+    end
+
+    def compute_params
+      @batch_obj = {}
+      @per_batch = {}
+      @action_prefix = false
+      @action['request']['params'].each do |param|
+        if param['target'].include?('[')
+          parts = param['target'].split('[')
+          pair = parts[0].split('.')
+          if pair.length > 1
+            @action_prefix = pair.first
+          end
+          batch_name = pair.last
+          batch_param = underscore(parts[1].sub(/.*?\./, ''))
+          batch_param = batch_param == "" ? underscore(param['name']) : batch_param
+          (@batch_obj[batch_name] ||= []) << {
+            batch_param.to_sym => underscore(param['name'] || param['path'])
+          }
+        else
+          @per_batch[param['target']] = underscore(param['name'])
+        end
+      end
+    end
+
+    def client_method
+      underscore(@action['request']['operation'])
+    end
+
+    def underscore(str)
+      Underscore.underscore(str)
+    end
+
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  class ResourceBatchBuilder
+
+    # @option options [required, Hash] :resource
+    # @option options [String] :resp_var_name ('resp')
+    def initialize(options)
+      @resource = options.fetch(:resource)
+      @resp_var_name = options.fetch(:resp_var_name, 'resp')
+      verify_resource!
+      @context = loop_context
+      @indent = options.fetch(:indent, '')
+    end
+
+    def build
+      code = ''
+      loops = self.send(:loops)
+      count = loops.size
+      loops.each.with_index do |loop_expression, n|
+        i = '  ' * n
+        code += "#{i}#{loop_expression}\n"
+        if n == count - 1
+          code += i + '  ' + Docstring.indent("batch << #{resource_class}.new(#{constructor_args})\n", i + '  ')
+        end
+      end
+      (count).times do |n|
+        i = '  ' * (count - n - 1)
+        code += "#{i}end\n"
+      end
+      code.rstrip
+    end
+
+    private
+
+    def resource_class
+      @resource['type']
+    end
+
+    def constructor_args
+      hash = {}
+      hash.update(identifiers)
+      hash[:data] = data_path if @resource['path']
+      hash[:client] = "@client"
+      HashFormatter.new(wrap:false, inline:true).format(hash)
+    end
+
+    def identifiers
+      (@resource['identifiers'] || []).inject({}) do |hash, identifier|
+        value = relative_identifier_path(identifier)
+        hash[underscore(identifier['target']).to_sym] = value
+        hash
+      end
+    end
+
+    def data_path
+      relative_identifier_path({
+        'source' => 'data',
+        'path' => @resource['path'],
+      })
+    end
+
+    def relative_identifier_path(identifier)
+      path = identifier['path']
+      if path && path.include?('[]')
+        prefix = loops.last.match(/\|(.+)\|/)[1]
+        suffix = underscore(path[common_prefix.length..-1])
+        unless @context == :response
+          suffix = suffix.gsub(/\.\w+/) { |word| "[:#{word[1..-1]}]" }
+        end
+        suffix.length == 0 ? prefix : prefix + suffix
+      else
+        ResourceValueSource.new(identifier).to_s
+      end
+    end
+
+    def common_prefix
+      paths = plural_paths
+      if paths.empty?
+        ''
+      elsif paths.size == 1
+        # grab everything upto and including the final []
+        paths.first.match(/(.+\[\]).*?$/)[1]
+      else
+        prefix = find_prefix(paths)
+        prefix = prefix.sub(/\[\].+?$/, '[]')
+        if prefix[-2..-1] != '[]'
+          msg = 'response paths must have a common prefix ending in [], got :'
+          msg << paths.inspect
+          raise ArgumentError, msg
+        else
+          prefix
+        end
+      end
+    end
+
+    def find_prefix(paths)
+      prefix = ''
+      loop.with_index do |_, n|
+        return prefix if paths.empty?
+        letter = paths[0][n]
+        paths.each do |path|
+          return prefix if path[n].nil?
+          return prefix if path[n] != letter
+        end
+        prefix += letter
+      end
+    end
+
+    def loops
+      loop_var =
+        case @context
+        when :data then 'data'
+        when :options then 'options'
+        when :response then "#{@resp_var_name}.data."
+        end
+
+      used_vars = Set.new
+      used_vars << loop_var
+
+      parts = common_prefix.split('[]')
+      parts = parts.map.with_index do |part,n|
+        part = underscore(part)
+        unless @context == :response
+          part = part.gsub(/\w+/) { |word| "[:#{word}]" }
+          part = part.gsub(/\./, '')
+        end
+        part = "#{loop_var}#{part}"
+        loop_var = loop_letter(part, used_vars)
+        part = part + ".each do |#{loop_var}|"
+        part
+      end
+      parts
+    end
+
+    def loop_letter(str, used_vars)
+      letter = if @context == :options
+        str.scan(/:\w/).last[1]
+      else
+        str.split('.').last[0]
+      end
+      n = 1
+      var = letter
+      while used_vars.include?(var)
+        n += 1
+        var = "#{letter}#{n}"
+      end
+      used_vars << var
+      var
+    end
+
+    def all_plural_paths
+      paths = {}
+      @resource['identifiers'].each do |i|
+        if i['path'] && i['path'].include?('[]')
+          paths[i['source']] ||= []
+          paths[i['source']] << i['path']
+        end
+      end
+      paths
+    end
+
+    def plural_paths
+      all_plural_paths.values.first
+    end
+
+    def verify_resource!
+      verify_plural_paths!
+    end
+
+    def verify_plural_paths!
+      paths = all_plural_paths
+      case paths.size
+      when 0
+        msg = 'expected at least one plural identifier path, got none'
+        raise ArgumentError, msg
+      when 1
+        case paths.keys.first
+        when 'requestParameter'
+        when 'response'
+        when 'data'
+        else
+          msg = "unsupported identifier source #{paths.keys.first.inspect}"
+          raise ArgumentError, msg
+        end
+      else
+        msg = 'mixing plural source types is not supported'
+        raise ArgumentError, msg
+      end
+    end
+
+    def loop_context
+      case all_plural_paths.keys
+      when ['response'] then :response
+      when ['data'] then :data
+      when ['requestParameter'] then :options
+      else
+        msg = "unable to determine loop context: #{@resource.inspect}"
+        raise msg
+      end
+    end
+
+    def underscore(str)
+      str.split('.').map do |part|
+        Underscore.underscore(part)
+      end.join('.')
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceBuilder
+
+    # @option options [required, Hash] :resource
+    # @option options [required, Boolean] :request_made
+    def initialize(options = {})
+      @resource = options.fetch(:resource)
+      @request_made = options.fetch(:request_made)
+    end
+
+    def build
+      "#{resource_class}.new(#{constructor_options})"
+    end
+
+    private
+
+    def resource_class
+      @resource['type']
+    end
+
+    def constructor_options
+      options = {}
+      options.update(identifiers)
+      options[:data] = data_path if @resource['path']
+      options[:client] = "@client"
+      HashFormatter.new(wrap:false).format(options)
+    end
+
+    def identifiers
+      (@resource['identifiers'] || []).inject({}) do |hash, identifier|
+        value = ResourceValueSource.new(identifier).to_s
+        hash[Underscore.underscore(identifier['target']).to_sym] = value
+        hash
+      end
+    end
+
+    def data_path
+      if @request_made
+        ResourceValueSource.new('source' => 'response', 'path' => @resource['path'])
+      else
+        ResourceValueSource.new('source' => 'data', 'path' => @resource['path'])
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceClientRequest
+    class << self
+
+      # @option options [required, Hash] :request
+      # @option options [Boolean] :resp (false)
+      # @option options [Boolean] :merge (true)
+      def build(options)
+        request = options.fetch(:request)
+        merge = options.fetch(:merge, true)
+        streaming = options.fetch(:streaming, false)
+        params = ResourceClientRequestParams.new(params: request['params'])
+        parts = []
+        parts << request_options(params) if merge
+        parts << assignment(options)
+        parts << "@client."
+        parts << operation_name(request)
+        parts << arguments(merge, params, streaming)
+        parts.join
+      end
+
+      private
+
+      def request_options(params)
+        if params.empty?
+          ''
+        elsif params.simple?
+          "options = options.merge(#{params})\n"
+        else
+          hash = params
+          hash = ' ' + hash unless hash[0] == "\n"
+          "options = Aws::Util.deep_merge(options,#{hash})\n"
+        end
+      end
+
+      def assignment(options)
+        if options.fetch(:resp, false)
+          'resp = '
+        else
+          ''
+        end
+      end
+
+      def operation_name(request)
+        Underscore.underscore(request['operation'])
+      end
+
+      def arguments(merge, params, streaming)
+        if merge
+          streaming ? '(options, &block)' : '(options)'
+        elsif params.empty?
+          ''
+        else
+          streaming ? "(#{params}, &block)" : "(#{params})"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  class ResourceClientReqeustDocumentation
+
+    def initialize(options)
+      @api = options.fetch(:api)
+      @method_name = options.fetch(:method_name)
+      @receiver = options.fetch(:receiver)
+      @resp_var = options.fetch(:resp_var, nil)
+      @request = options.fetch(:request)
+      @shape_ref = @api['operations'][@request['operation']]['input']
+      @returns = options.fetch(:returns, nil)
+      @skip = Set.new(options.fetch(:skip, []) + ResourceSkipParams.compute(input_shape, @request))
+    end
+
+    def build
+      Docstring.join_docstrings([
+        request_syntax_example,
+        param_tag,
+        option_tags,
+        return_tag,
+      ], block_comment: false, separator: false)
+    end
+
+    private
+
+    def request_syntax_example
+      if @shape_ref && Api.shape(@shape_ref, @api)['members'].count  - @skip.count > 0
+        SyntaxExample.new(
+          api: @api,
+          shape: input_shape,
+          method_name: @method_name,
+          receiver: @receiver,
+          resp_var: @resp_var,
+          skip: @skip,
+        ).format
+      else
+        # TODO : remove these empty examples, not really needed
+        <<-DOCS.rstrip
+# @example Request syntax with placeholder values
+#
+#   #{@receiver}.#{@method_name}()
+        DOCS
+      end
+    end
+
+    def param_tag
+      '# @param [Hash] options ({})'
+    end
+
+    def option_tags
+      if input_shape
+        input_shape['members'].map do |member_name, member_ref|
+          next if @skip.include?(member_name)
+          YardOptionTag.new(
+            name: Underscore.underscore(member_name),
+            required: input_shape.fetch('required', []).include?(member_name),
+            ruby_type: Api.ruby_input_type(member_ref, @api),
+            docstring: Docstring.html_to_markdown(Api.docstring(member_ref, @api)),
+          ).to_str
+        end
+      end
+    end
+
+    def input_shape
+      Api.shape(@shape_ref, @api)
+    end
+
+    def return_tag
+      if @returns
+        "# @return [#{@returns}]"
+      else
+        nil
+      end
+    end
+
+  end
+end