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

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class ResourceClass < View
+
+      def initialize(options)
+        @module_name = options.fetch(:module_name)
+        @class_name = options.fetch(:class_name)
+        api = options.fetch(:api)
+        resource = options.fetch(:resource)
+        @identifiers = ResourceIdentifier.build_list(resource)
+        @identifiers_method = ResourceIdentifiersMethod.build(@identifiers)
+        @data_attributes = ResourceAttribute.build_list(resource, api)
+        @load_method = ResourceLoadMethod.build(@class_name, resource)
+        @data_method = ResourceDataMethod.build(@class_name, resource)
+        @client_load_method = Underscore.underscore(resource['load']['request']['operation']) if resource['load']
+        @data_class = "Types::#{resource['shape']}"
+        @waiters = ResourceWaiter.build_list(resource, options[:waiters])
+        @wait_until = options[:waiters] # add #wait_until method if service has waiters
+        @actions = ResourceAction.build_list(@class_name, resource, api)
+        @associations = build_associations(options)
+        @batch_actions = ResourceBatchAction.build_list(@class_name, resource, api)
+        @shape = resource['shape']
+        @custom = options.fetch(:custom)
+      end
+
+      # @return [String]
+      attr_reader :module_name
+
+      # @return [String]
+      attr_reader :class_name
+
+      # @return [Array<ResourceIdentifier>]
+      attr_reader :identifiers
+
+      # @return [String]
+      attr_reader :identifiers_method
+
+      # @return [Array<ResourceAttribute>]
+      attr_reader :data_attributes
+
+      # @return [String]
+      attr_reader :data_class
+
+      # @return [String]
+      attr_reader :load_method
+
+      # @return [String]
+      attr_reader :data_method
+
+      # @return [String, nil]
+      attr_reader :client_load_method
+
+      # @return [Array<Waiter>]
+      attr_reader :waiters
+
+      # @return [Boolean]
+      attr_reader :wait_until
+
+      # @return [Array<ResourceAction>]
+      attr_reader :actions
+
+      # @return [Array<ResourceAssociation>]
+      attr_reader :associations
+
+      # @return [Array<ResourceBatchAction>]
+      attr_reader :batch_actions
+
+      # @return [String, nil]
+      attr_reader :shape
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @custom
+        GENERATED_SRC_WARNING
+      end
+
+      # @return [Boolean]
+      def waiters?
+        !@waiters.empty?
+      end
+
+      # @return [ResoruceWiater, nil]
+      def exists_waiter
+        @waiters.find { |w| w.name == 'exists' }
+      end
+
+      # @return [Boolean]
+      def actions?
+        actions.size > 0
+      end
+
+      # @return [Boolean]
+      def associations?
+        associations.size > 0
+      end
+
+      # @return [Boolean]
+      def batch_actions?
+        batch_actions.size > 0
+      end
+
+      # @return [Boolean]
+      def identifiers?
+        @identifiers.size > 0
+      end
+
+      private
+
+      def build_associations(options)
+        ResourceAssociation.build_list(
+          class_name: options.fetch(:class_name),
+          resource: options.fetch(:resource),
+          api: options.fetch(:api),
+          paginators: options.fetch(:paginators)
+        )
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class RootResourceClass < View
+
+      def initialize(options)
+        @module_name = options.fetch(:module_name)
+        @service_name = options.fetch(:service_name)
+        class_name = @module_name.split('::').last
+        api = options.fetch(:api)
+        resource = (options[:resources] || {})['service'] || {}
+        @actions = ResourceAction.build_list(class_name, resource, api)
+        @associations = ResourceAssociation.build_list(
+          class_name: class_name,
+          resource: resource,
+          api: api,
+          paginators: options.fetch(:paginators)
+        )
+        @custom = options.fetch(:custom)
+      end
+
+      # @return [String]
+      attr_reader :module_name
+
+      # @return [Array<ResourceAction>]
+      attr_reader :actions
+
+      # @return [Array<ResourceAssociation>]
+      attr_reader :associations
+
+      # @return [String]
+      attr_reader :service_name
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @custom
+        GENERATED_SRC_WARNING
+      end
+
+      # @return [Boolean]
+      def actions?
+        actions.size > 0
+      end
+
+      # @return [Boolean]
+      def associations?
+        associations.size > 0
+      end
+
+      # @return [Boolean]
+      def documentation?
+        actions? || associations?
+      end
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module AwsSdkCodeGenerator
@@ -5,11 +7,18 @@ module AwsSdkCodeGenerator
     class ServiceModule < View
 
       # @option options [required, Service] :service
+      # @option options [required, String] :prefix
       def initialize(options)
         @service = options.fetch(:service)
         @prefix = options.fetch(:prefix)
       end
 
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
       def full_name
         @service.full_name
       end
@@ -45,15 +54,15 @@ module AwsSdkCodeGenerator
       # @return [Array<String>]
       def relative_requires
         paths = Set.new
-        paths << "#{prefix}/types"
-        paths << "#{prefix}/client_api"
-        paths << "#{prefix}/client"
-        paths << "#{prefix}/errors"
-        paths << "#{prefix}/waiters" if @service.waiters
-        paths << "#{prefix}/resource"
+        paths << "#{@prefix}/types"
+        paths << "#{@prefix}/client_api"
+        paths << "#{@prefix}/client"
+        paths << "#{@prefix}/errors"
+        paths << "#{@prefix}/waiters" if @service.waiters
+        paths << "#{@prefix}/resource"
         if @service.resources && @service.resources['resources']
           @service.resources['resources'].keys.each do |resource_name|
-            path = "#{prefix}/#{underscore(resource_name)}"
+            path = "#{@prefix}/#{underscore(resource_name)}"
             if paths.include?(path)
               raise "resource path conflict for `#{resource_name}'"
             else
@@ -61,7 +70,14 @@ module AwsSdkCodeGenerator
             end
           end
         end
-        paths << "#{prefix}/customizations"
+        paths << "#{@prefix}/customizations"
+        if @service.api['metadata']['protocolSettings'] &&
+          @service.api['metadata']['protocolSettings']['h2'] == 'eventstream'
+          paths << "#{@prefix}/async_client"
+          paths << "#{@prefix}/event_streams"
+        elsif eventstream_shape?
+          paths << "#{@prefix}/event_streams"
+        end
         paths.to_a
       end
 
@@ -70,16 +86,16 @@ module AwsSdkCodeGenerator
       end
 
       def example_operation_name
+        raise "no operations found for the service" if @service.api['operations'].empty?
         underscore(@service.api['operations'].keys.first)
-        nil
       end
 
-      private
-
-      def prefix
-        @prefix
+      def eventstream_shape?
+        @service.api['shapes'].each do |_, shape_ref|
+          return true if shape_ref['eventstream']
+        end
+        false
       end
-
     end
   end
 end

data/lib/aws-sdk-code-generator/views/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AwsSdkCodeGenerator
   module Views
     module Spec
@@ -13,11 +15,18 @@ module AwsSdkCodeGenerator
           @gem_dependencies = service.gem_dependencies.map do |gem_name, _|
             { dependency: gem_name }
           end
+          @custom = service.protocol == 'api-gateway'
         end
 
         attr_reader :gem_name
         attr_reader :gem_dependencies
 
+        # @return [String|nil]
+        def generated_src_warning
+          return if @custom
+          GENERATED_SRC_WARNING
+        end
+
       end
     end
   end

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

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module AwsSdkCodeGenerator
+  module Views
+    class TypesModule < View
+
+      include Helper
+
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+        @api = @service.api
+        @input_shapes = compute_input_shapes(@service.api)
+      end
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      def module_name
+        @service.module_name
+      end
+
+      # @return [Array<StructClass>]
+      def structures
+        unless @service.protocol_settings.empty?
+          if @service.protocol_settings['h2'] == 'eventstream'
+            @service.api['shapes'].each do |_, shape|
+              if shape['eventstream']
+                # add event trait to all members if not exists
+                shape['members'].each do |name, ref|
+                  @service.api['shapes'][ref['shape']]['event'] = true
+                end
+              end
+            end
+          end
+        end
+        @service.api['shapes'].inject([]) do |list, (shape_name, shape)|
+          # APIG model can have input/output shape with downcase and '__'
+          if @service.protocol == 'api-gateway'
+            shape_name = lstrip_prefix(upcase_first(shape_name))
+          end
+          # eventstream shape will be inheriting from enumerator
+          if shape['eventstream']
+            list
+          elsif shape['type'] == 'structure'
+            struct_members = struct_members(shape)
+            sensitive_params = struct_members.select(&:sensitive).map do |m|
+              m.member_name.to_sym
+            end
+            list << StructClass.new(
+              class_name: shape_name,
+              members: struct_members,
+              sensitive_params: sensitive_params,
+              documentation: struct_class_docs(shape_name)
+            )
+          else
+            list
+          end
+        end
+      end
+
+      # return [Array<EventStreamClass>]
+      def eventstreams
+        @service.api['shapes'].inject([]) do |list, (shape_name, shape)|
+          if shape['eventstream']
+            list << EventStreamClass.new(
+              class_name: shape_name,
+              types: struct_members(shape),
+              documentation: eventstream_class_docs(shape_name)
+            )
+          else
+            list
+          end
+        end
+      end
+
+      private
+
+      def struct_members(shape)
+        return if shape['members'].nil?
+        members = shape['members'].map do |member_name, member_ref|
+          sensitive = !!(member_ref['sensitive'] ||
+            @api['shapes'][member_ref['shape']]['sensitive'])
+          StructMember.new(
+            member_name: underscore(member_name),
+            sensitive: sensitive
+          )
+        end
+        if shape['event']
+          members << StructMember.new(member_name: 'event_type')
+        end
+        members
+      end
+
+      def struct_class_docs(shape_name)
+        join_docstrings([
+          html_to_markdown(Api.docstring(shape_name, @api)),
+          input_example_docs(shape_name),
+          attribute_macros_docs(shape_name),
+          see_also_tag(shape_name),
+        ])
+      end
+
+      def eventstream_class_docs(shape_name)
+        join_docstrings([
+          html_to_markdown(Api.docstring(shape_name, @api)),
+          input_example_docs(shape_name),
+          eventstream_docs(shape_name),
+          see_also_tag(shape_name),
+        ])
+      end
+
+      def eventstream_docs(shape_name)
+        "EventStream is an Enumerator of Events.\n"\
+        " #event_types #=> Array, returns all modeled event types in the stream"
+      end
+
+      def input_example_docs(shape_name)
+        if @input_shapes.include?(shape_name)
+          return if shape(shape_name)['members'].nil?
+          if shape(shape_name)['members'].empty?
+            note = '@api private'
+          else
+            note = "@note When making an API call, you may pass #{shape_name}\n"
+            note += "  data as a hash:\n\n"
+            note += '      ' + SyntaxExampleHash.new(
+              shape: shape(shape_name),
+              api: @service.api,
+            ).format('      ')
+          end
+        end
+      end
+
+      def attribute_macros_docs(shape_name)
+        # APIG model downcase shape name in origin or "__" prefix in origin
+        if @service.protocol == 'api-gateway'
+          if shape(shape_name).nil?
+            if !shape(downcase_first(shape_name)).nil?
+              shape_name = downcase_first(shape_name)
+            elsif !shape(apig_prefix(shape_name)).nil?
+              shape_name = apig_prefix(shape_name)
+            else
+              shape_name = apig_prefix(downcase_first(shape_name))
+            end
+          end
+        end
+        return if shape(shape_name)['members'].nil?
+        shape(shape_name)['members'].map do |member_name, member_ref|
+          docs = Api.docstring(member_ref, @api).to_s
+          docs += idempotency_token_msg if idempotency_token?(member_ref)
+          docs = html_to_markdown(docs, line_width: 68)
+          docs = docs.to_s.lines.to_a.join('  ')
+          macro = "@!attribute [rw] #{underscore(member_name)}\n"
+          macro += "  #{docs}\n" unless docs == ''
+          macro += "  @return [#{Api.ruby_type(member_ref, @api)}]"
+          macro
+        end
+      end
+
+      def see_also_tag(shape_name)
+        uid = @api['metadata']['uid']
+        if @api['metadata']['protocol'] != 'api-gateway' && Crosslink.taggable?(uid)
+          Crosslink.tag_string(uid, shape_name)
+        end
+      end
+
+      def compute_input_shapes(api)
+        inputs = Set.new
+        (api['operations'] || {}).each do |_, operation|
+          visit_inputs(operation['input'], inputs) if operation['input']
+        end
+        inputs
+      end
+
+      def idempotency_token?(member_ref)
+        member_ref['idempotencyToken'] || shape(member_ref)['idempotencyToken']
+      end
+
+      def idempotency_token_msg
+        "<p><b>A suitable default value is auto-generated.</b> You should normally not need to pass this option.</p>"
+      end
+
+      def visit_inputs(shape_ref, inputs)
+        return if inputs.include?(shape_ref['shape']) # recursion
+        inputs << shape_ref['shape']
+        s = shape(shape_ref)
+        raise "cannot locate shape #{shape_ref['shape']}" if s.nil?
+        case s['type']
+        when 'structure'
+          return if s['members'].nil?
+          s['members'].each_pair do |_, member_ref|
+            visit_inputs(member_ref, inputs)
+          end
+        when 'list'
+          visit_inputs(s['member'], inputs)
+        when 'map'
+          visit_inputs(s['key'], inputs)
+          visit_inputs(s['value'], inputs)
+        end
+      end
+
+      def shape(shape_ref)
+        Api.resolve(shape_ref, @api)[1]
+      end
+
+      class EventStreamClass
+
+        def initialize(options)
+          @class_name = options.fetch(:class_name)
+          @types = options.fetch(:types)
+          @documentation = options.fetch(:documentation)
+          if @types.nil? || @types.empty?
+            @empty = true
+          else
+            @empty = false
+            @types.last.last = true
+          end
+        end
+
+        # @return [String]
+        attr_accessor :class_name
+
+        # @return [Array<StructMember>]
+        attr_accessor :types
+
+        # @return [String, nil]
+        attr_accessor :documentation
+
+        # @return [Boolean]
+        def empty?
+          @empty
+        end
+
+      end
+
+      class StructClass
+
+        def initialize(options)
+          @class_name = options.fetch(:class_name)
+          @members = options.fetch(:members)
+          @documentation = options.fetch(:documentation)
+          @sensitive_params = options.fetch(:sensitive_params)
+          if @members.nil? || @members.empty?
+            @empty = true
+          else
+            @empty = false
+            @members.last.last = true
+          end
+        end
+
+        # @return [String]
+        attr_accessor :class_name
+
+        # @return [Array<StructMember>]
+        attr_accessor :members
+
+        # @return [String, nil]
+        attr_accessor :documentation
+
+        # @return [Array<Symbol>]
+        attr_accessor :sensitive_params
+
+        # @return [Boolean]
+        def empty?
+          @empty
+        end
+      end
+
+      class StructMember
+
+        def initialize(options)
+          @member_name = options.fetch(:member_name)
+          @sensitive = options.fetch(:sensitive, false)
+          @last = false
+        end
+
+        # @return [String]
+        attr_accessor :member_name
+
+        # @return [Boolean]
+        attr_accessor :sensitive
+
+        # @return [Boolean]
+        attr_accessor :last
+
+      end
+    end
+  end
+end