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

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

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceDataMethod
+    class << self
+
+      # @param [String] class_name
+      # @param [Hash] resource
+      # @return [ResourceMethod]
+      def build(class_name, resource)
+        if resource['load']
+          data_method(class_name, resource)
+        elsif resource['shape']
+          data_without_load(class_name, resource)
+        else
+          empty_data_method
+        end
+      end
+
+      private
+
+      def empty_data_method
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'data'
+          m.arguments = nil
+          m.documentation = "# @api private\n# @return [EmptyStructure]"
+          m.code = '@data'
+        end
+      end
+
+      def data_without_load(class_name, resource)
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'data'
+          m.arguments = nil
+          m.documentation = "# @raise [NotImplementedError] Raises when {#data_loaded?} is `false`.\n# @return [Types::#{resource['shape']}]\n#   Returns the data for this {#{class_name}}."
+          m.code = "load unless @data\n@data"
+        end
+      end
+
+      def data_method(class_name, resource)
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'data'
+          m.arguments = nil
+          m.documentation = "# @return [Types::#{resource['shape']}]\n#   Returns the data for this {#{class_name}}. Calls\n#   {Client##{Underscore.underscore(resource['load']['request']['operation'])}} if {#data_loaded?} is `false`."
+          m.code = "load unless @data\n@data"
+        end
+      end
+
+      def data_path(resource)
+        path = resource['load']['path']
+        if path == '@'
+          'data'
+        else
+          Underscore.underscore_jmespath(path)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceHasAssociation
+    class << self
+
+      # @return [ResourceMethod]
+      def build(options)
+        assoc = options.fetch(:assoc)
+        params = compute_params(assoc)
+        ResourceMethod.new.tap do |m|
+          m.method_name = Underscore.underscore(options.fetch(:name))
+          m.arguments = arguments(params)
+          m.documentation = documentation(assoc, params)
+          m.code = code(assoc)
+        end
+      end
+
+      private
+
+      def code(assoc)
+        parts = []
+        if plural?(assoc)
+          parts << 'batch = []'
+          parts << ResourceBatchBuilder.new(resource: assoc['resource']).build
+          parts << "#{assoc['resource']['type']}::Collection.new([batch], size: batch.size)"
+        elsif nullable?(assoc) # singular association
+          parts << "if #{null_checks(assoc)}"
+          parts << "  #{Docstring.indent(builder(assoc))}"
+          parts << 'else'
+          parts << '  nil'
+          parts << 'end'
+        else
+          parts << builder(assoc)
+        end
+        parts.join("\n").rstrip
+      end
+
+      def builder(assoc)
+        ResourceBuilder.new(resource: assoc['resource'], request_made: false).build
+      end
+
+      def documentation(assoc, params)
+        parts = []
+        params.each do |param|
+          parts << "# @param [#{param[:type]}] #{param[:name]}"
+        end
+        parts << "# @return [#{return_type(assoc)}]"
+        parts.join("\n").rstrip
+      end
+
+      def return_type(assoc)
+        type = assoc['resource']['type']
+        if plural?(assoc)
+          "#{type}::Collection"
+        elsif nullable?(assoc)
+          "#{type}, nil"
+        else
+          type
+        end
+      end
+
+      def compute_params(assoc)
+        params = []
+        (assoc['resource']['identifiers'] || []).each do |identifier|
+          if identifier['source'] == 'input'
+            params << {
+              name: Underscore.underscore(identifier['target']),
+              type: 'String',
+            }
+          end
+        end
+        params
+      end
+
+      def arguments(params)
+        if params.empty?
+          nil
+        else
+          params.map { |p| p[:name] }.join(', ')
+        end
+      end
+
+      def plural?(assoc)
+        plural = false
+        r = assoc['resource']
+        (r['identifiers'] || []).each do |i|
+          if i['path'] && i['path'].include?('[]')
+            plural = true
+            break
+          end
+        end
+        plural = true if r['data'] && r['data'].include?('[]')
+        plural
+      end
+
+      def nullable?(assoc)
+        !data_identifiers(assoc).empty?
+      end
+
+      def data_identifiers(assoc)
+        identifiers = []
+        (assoc['resource']['identifiers'] || []).each do |i|
+          identifiers << i if i['source'] == 'data'
+        end
+        identifiers
+      end
+
+      def null_checks(assoc)
+        data_identifiers(assoc).map do |i|
+          ResourceValueSource.new(i)
+        end.join(' && ')
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceHasManyAssociation
+    class << self
+
+      # @return [ResourceMethod]
+      def build(options)
+        ResourceMethod.new.tap do |m|
+          m.method_name = Underscore.underscore(options.fetch(:name))
+          m.arguments = 'options = {}'
+          m.code = ResourceHasManyAssociationCode.new(options).build
+          m.documentation = documentation(options)
+        end
+      end
+
+      private
+
+      def documentation(options)
+        ResourceClientReqeustDocumentation.new(
+          method_name: Underscore.underscore(options.fetch(:name)),
+          receiver: Underscore.underscore(options.fetch(:class_name)),
+          resp_var: Underscore.underscore(options.fetch(:name)),
+          returns: "#{options.fetch(:assoc)['resource']['type']}::Collection",
+          request: options.fetch(:assoc)['request'],
+          api: options.fetch(:api),
+          skip: paging_options(options),
+        ).build
+      end
+
+      def paging_options(options)
+        paginators = options.fetch(:paginators, nil)
+        operation_name = options.fetch(:assoc).fetch('request').fetch('operation')
+        if paginated?(operation_name, paginators)
+          skip = []
+          skip << paginators['pagination'][operation_name]['input_token']
+          skip << paginators['pagination'][operation_name]['limit_key']
+          skip.compact
+        else
+          []
+        end
+      end
+
+      def paginated?(operation_name, paginators)
+        paginators &&
+        paginators['pagination'][operation_name] &&
+        paginators['pagination'][operation_name]['input_token']
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceHasManyAssociationCode
+
+    def initialize(options)
+      @assoc = options.fetch(:assoc)
+      @paginators = options.fetch(:paginators, nil)
+      @collection_class = "#{options.fetch(:assoc)['resource']['type']}::Collection"
+    end
+
+    def build
+      if paginated?
+        paginated_request
+      else
+        non_paginated_request
+      end
+    end
+
+    private
+
+    def paginated_request
+      <<-CODE.rstrip
+batches = Enumerator.new do |y|
+  #{client_request}
+  resp.each_page do |page|
+    batch = []
+    #{batch_builder(resp_var_name: 'page', indent: '    ')}
+    y.yield(batch)
+  end
+end
+#{@collection_class}.new(batches)
+      CODE
+    end
+
+    def non_paginated_request
+      <<-CODE.rstrip
+batches = Enumerator.new do |y|
+  batch = []
+  #{client_request}
+  #{batch_builder(indent: '  ')}
+  y.yield(batch)
+end
+#{@collection_class}.new(batches)
+      CODE
+    end
+
+    def client_request
+      Docstring.indent(ResourceClientRequest.build(
+        request: @assoc['request'],
+        merge: true,
+        resp: true,
+      ), '  ')
+    end
+
+    def batch_builder(options)
+      Docstring.indent(
+        ResourceBatchBuilder.new(
+          resource: @assoc['resource'],
+          resp_var_name: options.fetch(:resp_var_name, 'resp'),
+        ).build,
+      options[:indent])
+    end
+
+    def paginated?
+      @paginators &&
+      @paginators['pagination'][operation_name] &&
+      @paginators['pagination'][operation_name]['input_token']
+    end
+
+    def operation_name
+      @assoc['request']['operation']
+    end
+
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceIdentifier
+
+    # @return [String]
+    attr_accessor :name
+
+    # @return [String]
+    attr_accessor :type
+
+    # @return [String, nil]
+    attr_accessor :offset
+
+    # @return [String, nil]
+    attr_accessor :alias
+
+    class << self
+
+      # @return [Array<ResourceIdentifier>)
+      def build_list(resource)
+        resource.fetch('identifiers', []).each.with_index.map do |i, n|
+          ResourceIdentifier.new.tap do |identifier|
+            identifier.name = Underscore.underscore(i['name'])
+            identifier.type = Docstring.ucfirst(i['type'] || 'String')
+            identifier.offset = n
+            identifier.alias = identifier_alias(i)
+          end
+        end
+      end
+
+      private
+
+      def identifier_alias(identifier)
+        if identifier['memberName'] && identifier['memberName'] != identifier['name']
+          Underscore.underscore(identifier['memberName'])
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceIdentifiersMethod
+    class << self
+
+      # @param [ResourceIdentifier] identifiers
+      # @return [ResourceMethod
+      def build(identifiers)
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'identifiers'
+          m.arguments = nil
+          m.documentation = "# @deprecated\n# @api private"
+          m.code = code(identifiers)
+        end
+      end
+
+      private
+
+      def code(identifiers)
+        hash = identifiers.inject({}) do |hash, identifier|
+          hash[identifier.name.to_sym] = "@#{identifier.name}"
+          hash
+        end
+        HashFormatter.new(inline: true).format(hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  class ResourceLoadMethod
+    class << self
+
+      # @param [String] class_name
+      # @param [Hash] resource
+      # @return [ResourceMethod]
+      def build(class_name, resource)
+        if resource['load']
+          load_method(class_name, resource)
+        else
+          empty_load_method
+        end
+      end
+
+      private
+
+      def empty_load_method
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'load'
+          m.arguments = nil
+          m.documentation = "# @raise [NotImplementedError]\n# @api private"
+          m.code = "msg = \"#load is not implemented, data only available via enumeration\"\nraise NotImplementedError, msg"
+        end
+      end
+
+      def load_method(class_name, resource)
+        ResourceMethod.new.tap do |m|
+          m.method_name = 'load'
+          m.arguments = nil
+          m.documentation = <<-DOCS.rstrip
+# Loads, or reloads {#data} for the current {#{class_name}}.
+# Returns `self` making it possible to chain methods.
+#
+#     #{Underscore.underscore(class_name)}.reload.data
+#
+# @return [self]
+          DOCS
+          m.code = <<-CODE.rstrip
+#{request(resource)}
+@data = resp.#{data_path(resource)}
+self
+          CODE
+        end
+      end
+
+      def request(resource)
+        ResourceClientRequest.build(
+          request: resource['load']['request'],
+          merge: false,
+          resp: true
+        )
+      end
+
+      def data_path(resource)
+        path = resource['load']['path']
+        if path == '@'
+          'data'
+        else
+          Underscore.underscore_jmespath(path)
+        end
+      end
+
+    end
+  end
+end

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