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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceActionCode
+
+    def initialize(options)
+      action = options.fetch(:action)
+      @request = action.fetch('request')
+      @resource = action.fetch('resource', nil)
+      @streaming = options.fetch(:streaming, false)
+    end
+
+    def build
+      parts = []
+      if batch_action?
+        parts << 'batch = []'
+        parts << client_request
+        parts << ResourceBatchBuilder.new(resource: @resource).build
+        parts << "#{resource_type}::Collection.new([batch], size: batch.size)"
+      elsif resource_action?
+        parts << client_request(
+          @resource['identifiers'].any? { |i| i['source'] == 'response' } || @resource['path']
+        )
+        parts << ResourceBuilder.new(resource: @resource, request_made: true).build
+      else
+        parts << client_request
+        parts << 'resp.data'
+      end
+      parts.join("\n").rstrip
+    end
+
+    private
+
+    def client_request(resp = true)
+      ResourceClientRequest.build(request: @request, resp: resp, streaming: @streaming)
+    end
+
+    def resource_type
+      @resource['type']
+    end
+
+    def batch_action?
+      if resource_action?
+        paths = (@resource['identifiers'] || []).map {|i| i['path'] }
+        paths << @resource['path']
+        paths.compact.any? { |path| path.match(/\[/) }
+      else
+        false
+      end
+    end
+
+    def resource_action?
+      !!@resource
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceAssociation
+    class << self
+
+      # @return [Array<ResourceMethod>]
+      def build_list(options)
+        associations = []
+        associations += has_associations(options)
+        associations += has_many_associations(options)
+        associations.sort_by(&:method_name)
+      end
+
+      private
+
+      def has_associations(options)
+        options.fetch(:resource).fetch('has', {}).map do |name, assoc|
+          ResourceHasAssociation.build(options.merge(
+            name: name,
+            assoc: assoc,
+          ))
+        end
+      end
+
+      def has_many_associations(options)
+        options.fetch(:resource).fetch('hasMany', {}).map do |name, assoc|
+          ResourceHasManyAssociation.build(options.merge(
+            name: name,
+            assoc: assoc,
+          ))
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceAttribute
+
+    # @return [String]
+    attr_accessor :name
+
+    # @return [String, nil]
+    attr_accessor :documentation
+
+    class << self
+
+      # @return [Array<ResourceAttribute>)
+      def build_list(resource, api)
+        if resource['shape']
+          data_attribute_names(resource, api).map do |member_name, member_ref|
+            docstring = Docstring.block_comment(
+              Docstring.html_to_markdown(Api.docstring(member_ref, api))
+            )
+            docstring = (docstring ? "#{docstring}\n" : '')
+            type = Api.ruby_type(member_ref, api)
+            ResourceAttribute.new.tap do |attr|
+              attr.name = Underscore.underscore(member_name)
+              attr.documentation = docstring + "# @return [#{type}]"
+            end
+          end
+        else
+          []
+        end
+
+      end
+
+      private
+
+      def data_attribute_names(resource, api)
+
+        identifiers = resource['identifiers']
+
+        skip = Set.new
+
+        # do no duplicate identifiers
+        identifiers.each do |i|
+          skip << i['name']
+          skip << i['memberName'] if i.key?('memberName')
+        end
+
+        # do no duplicate action names
+        (resource['actions'] || {}).keys.each do |action_name|
+          skip << action_name
+        end
+
+        # do no duplicate has association names
+        (resource['has'] || {}).keys.each do |association_name|
+          skip << association_name
+        end
+
+        # do no duplicate hasMany association names
+        (resource['hasMany'] || {}).keys.each do |association_name|
+          skip << association_name
+        end
+
+        shape = Api.shape(resource['shape'], api)
+        members = shape['members'] || {}
+        Enumerator.new do |y|
+          members.each do |member_name, member_ref|
+            unless skip.include?(member_name)
+              y.yield(member_name, member_ref)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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