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

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

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceClientRequestParams < String
+
+    include Helper
+
+    # @option options [Array] :params ([])
+    def initialize(options = {})
+      @params = options.fetch(:params, nil) || []
+      super(format_params)
+    end
+
+    def simple?
+      @params.all? { |p| p['target'].match(/^\w+$/) }
+    end
+
+    def empty?
+      @params.empty?
+    end
+
+    def size
+      @params.size
+    end
+
+    private
+
+    def format_params
+      hash = {}
+      @params.each do |param|
+        ParamTarget.new(param).apply(hash, ResourceValueSource.new(param))
+      end
+      formatter = HashFormatter.new(wrap:false, inline: @params.count == 1)
+      params = formatter.format(hash)
+      @params.size == 1 ? params.strip : params
+    end
+
+    class ParamTarget
+
+      def initialize(param)
+        @target = param['target']
+        @steps = []
+        @target.scan(/\w+|\[\]|\[\*\]|\[[0-9]+\]/) do |step|
+          case step
+          when /\[\d+\]/ then @steps += [:array, step[1..-2].to_i]
+          when /\[\*\]/ then @steps += [:array, :n]
+          when '[]' then @steps += [:array, -1]
+          else @steps += [:hash, Underscore.underscore(step).to_sym]
+          end
+        end
+        @steps.shift
+        @final = @steps.pop
+      end
+
+      # @return [String] target
+      attr_reader :target
+
+      def apply(hash, value, options = {})
+        resource_index = options.fetch(:resource_index, 0)
+        if @final == -1
+          build_context(hash, resource_index) << value
+        else
+          build_context(hash, resource_index)[@final] = value
+        end
+        hash
+      end
+
+      private
+
+      def build_context(params, n)
+        @steps.each_slice(2).inject(params) do |context, (key, type)|
+          entry = type == :array ? [] : {}
+          if key == -1
+            context << entry
+            entry
+          elsif key == :n
+            context[n] ||= entry
+          else
+            context[key] ||= entry
+          end
+        end
+      end
+
+    end
+  end
+end