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

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class EndpointProviderClass < View
+
+      # @option options [required, Service] :service
+      # @option options [required, Hash] :endpoint_rules
+      def initialize(options)
+        @service = options.fetch(:service)
+        @endpoint_rules = @service.endpoint_rules
+
+        version = @endpoint_rules['version']
+        return if version&.match(/^\d+\.\d+$/) # && version == '1.0'
+
+        raise 'Endpoint Rules version must be 1.0'
+      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
+
+      def endpoint_rules_code
+        res = StringIO.new
+        # map parameters first
+        @endpoint_rules["parameters"].each do |k,_v|
+          res << indent("#{underscore(k)} = parameters.#{underscore(k)}\n", 3)
+        end
+
+        # map rules
+        @endpoint_rules["rules"].each do |rule|
+          case rule["type"]
+          when "endpoint"
+            res << endpoint_rule(rule, 3)
+          when "error"
+            res << error_rule(rule, 3)
+          when "tree"
+            res << tree_rule(rule, 3)
+          else
+            raise "Unknown rule type: #{rule['type']}"
+          end
+        end
+
+        # if no rules match, raise an error
+        res << indent("raise ArgumentError, 'No endpoint could be resolved'\n", 3)
+
+        res.string
+      end
+
+      private
+
+      def endpoint_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << endpoint(rule['endpoint'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << endpoint(rule['endpoint'], levels)
+        end
+        res.string
+      end
+
+      def endpoint(endpoint, levels)
+        res = StringIO.new
+        res << "return Aws::Endpoints::Endpoint.new(url: #{str(endpoint['url'])}"
+        if endpoint['headers']
+          res << ", headers: #{templated_hash_to_s(endpoint['headers'])}"
+        end
+        if endpoint['properties']
+          res << ", properties: #{templated_hash_to_s(endpoint['properties'])}"
+        end
+        res << ")\n"
+        indent(res.string, levels)
+      end
+
+      def templated_hash_to_s(hash)
+        template_hash_values(hash).to_s.gsub('\#{', '#{') # unescape references
+      end
+
+      def template_hash_values(hash)
+        hash.inject({}) { |h, (k, v)| h[k] = template_hash_value(v); h }
+      end
+
+      def template_hash_value(value)
+        case value
+        when Hash
+          template_hash_values(value)
+        when Array
+          value.map { |v| template_hash_value(v) }
+        when String
+          template_str(value, false)
+        else
+          value
+        end
+      end
+
+      def error_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << error(rule['error'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << error(rule['error'], levels)
+        end
+        res.string
+      end
+
+      def error(error, levels)
+        indent("raise ArgumentError, #{str(error)}\n", levels)
+      end
+
+      def tree_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << tree_rules(rule['rules'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << tree_rules(rule['rules'], levels)
+        end
+        res.string
+      end
+
+      def tree_rules(rules, levels)
+        res = StringIO.new
+        rules.each do |rule|
+          case rule["type"]
+          when "endpoint"
+            res << endpoint_rule(rule, levels)
+          when "error"
+            res << error_rule(rule, levels)
+          when "tree"
+            res << tree_rule(rule, levels)
+          else
+            raise "Unknown rule type: #{rule['type']}"
+          end
+        end
+        res.string
+      end
+
+      def conditions(conditions, level)
+        res = StringIO.new
+        cnd_str = conditions.map { |c| condition(c) }.join(" && ")
+        res << indent("if #{cnd_str}\n", level)
+        res.string
+      end
+
+      def condition(condition)
+        if condition['assign']
+          "(#{underscore(condition['assign'])} = #{fn(condition)})"
+        else
+          fn(condition)
+        end
+      end
+
+      def str(s)
+        if s.is_a?(Hash)
+          if s['ref']
+            underscore(s['ref'])
+          elsif s['fn']
+            fn(s)
+          else
+            raise "Unknown string type: #{s}"
+          end
+        else
+          template_str(s)
+        end
+      end
+
+      def template_str(string, wrap=true)
+        string.scan(/\{.+?\}/).each do |capture|
+          value = capture[1..-2] # strips curly brackets
+          string = string.gsub(capture, '#{' + template_replace(value) + '}')
+        end
+        string = string.gsub('"', '\"')
+        wrap ? "\"#{string}\"" : string
+      end
+
+      def template_replace(value)
+        indexes = value.split("#")
+        res = underscore(indexes.shift)
+        res += indexes.map do |index|
+          "['#{index}']"
+        end.join("")
+        res
+      end
+
+      def fn(fn)
+        args = fn['argv'].map {|arg| fn_arg(arg)}.join(", ")
+        "#{fn_name(fn['fn'])}(#{args})"
+      end
+
+      def fn_arg(arg)
+        if arg.is_a?(Hash)
+          if arg['ref']
+            underscore(arg['ref'])
+          elsif arg['fn']
+            fn(arg)
+          else
+            raise "Unexpected argument type: #{arg}"
+          end
+        elsif arg.is_a?(String)
+          template_str(arg)
+        else
+          arg
+        end
+      end
+
+      def fn_name(fn)
+        case fn
+        when 'isSet'
+          "Aws::Endpoints::Matchers.set?"
+        when 'not'
+          "Aws::Endpoints::Matchers.not"
+        when 'getAttr'
+          "Aws::Endpoints::Matchers.attr"
+        when 'substring'
+          "Aws::Endpoints::Matchers.substring"
+        when 'stringEquals'
+          "Aws::Endpoints::Matchers.string_equals?"
+        when 'booleanEquals'
+          "Aws::Endpoints::Matchers.boolean_equals?"
+        when 'uriEncode'
+          "Aws::Endpoints::Matchers.uri_encode"
+        when 'parseURL'
+          "Aws::Endpoints::Matchers.parse_url"
+        when 'isValidHostLabel'
+          "Aws::Endpoints::Matchers.valid_host_label?"
+        when 'aws.partition'
+          "Aws::Endpoints::Matchers.aws_partition"
+        when 'aws.parseArn'
+          "Aws::Endpoints::Matchers.aws_parse_arn"
+        when 'aws.isVirtualHostableS3Bucket'
+          "Aws::Endpoints::Matchers.aws_virtual_hostable_s3_bucket?"
+        else
+          raise "Function not found: #{@fn}"
+        end
+      end
+
+      def indent(s, levels=3)
+        ("  " * levels) + s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class EndpointsModule < View
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+
+        @parameters = @service.endpoint_rules.fetch('parameters', {})
+
+        @endpoint_classes = @service.api['operations'].each.with_object([]) do
+          |(name, op), array|
+          array << EndpointClass.new(
+            name: name,
+            parameters: endpoint_parameters_for_operation(op)
+          )
+        end
+      end
+
+      # @return [Array<EndpointClass>]
+      attr_reader :endpoint_classes
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      def module_name
+        @service.module_name
+      end
+
+      class EndpointClass
+        def initialize(options)
+          @name = options[:name]
+          @parameters = options[:parameters]
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [Array<EndpointParameter>]
+        attr_reader :parameters
+
+        def has_endpoint_built_in?
+          parameters.any? { |p| p.param_data['builtIn'] == 'SDK::Endpoint' }
+        end
+      end
+
+      class EndpointParameter
+        def initialize(options)
+          @key = options[:key]
+          @value = options[:value]
+          @source = options[:source]
+          @param_data = options[:param_data]
+        end
+
+        # @return [String]
+        attr_accessor :key
+
+        # @return [String]
+        attr_accessor :value
+
+        # @return [String]
+        attr_accessor :source
+
+        # @return [Hash]
+        attr_accessor :param_data
+
+        def static_string?
+          @source == 'staticContextParam' && value.is_a?(String)
+        end
+      end
+
+
+      private
+
+      def endpoint_parameters_for_operation(operation)
+        @parameters.each.with_object([]) do |(param_name, param_data), endpoint_parameters|
+          value, source = endpoint_parameter_value(
+            operation, param_name, param_data
+          )
+
+          endpoint_parameters << EndpointParameter.new(
+            key: Underscore.underscore(param_name),
+            value: value,
+            source: source,
+            param_data: param_data
+          )
+        end
+      end
+
+      # Most to least
+      # staticContextParams
+      # contextParam
+      # clientContextParams
+      # Built-In Bindings
+      # Built-in binding default values
+      def endpoint_parameter_value(operation, param_name, param_data)
+        value, source = [
+          static_context_param(operation, param_name), 'staticContextParam'
+        ]
+        value, source = [
+          context_param_value(operation, param_name), 'contextParam'
+        ] unless value
+        value, source = [
+          client_context_param_value(param_name, param_data),
+          'clientContextParam'
+        ] unless value
+        value, source = [
+          built_in_client_context_param_value(param_data), 'builtIn'
+        ] unless value
+
+        [value || 'nil', source]
+      end
+
+      def client_context_param_value(param_name, param_data)
+        if @service.api['clientContextParams']&.key?(param_name) &&
+           !param_data['builtIn']
+          "context.config.#{Underscore.underscore(param_name)}"
+        end
+      end
+
+      def built_in_client_context_param_value(param_data)
+        case param_data['builtIn']
+        when 'AWS::Region'
+          'context.config.region'
+        when 'AWS::UseFIPS'
+          'context.config.use_fips_endpoint'
+        when 'AWS::UseDualStack'
+          if @service.name == 'S3' || @service.name == 'S3Control'
+            'context[:use_dualstack_endpoint]'
+          else
+            'context.config.use_dualstack_endpoint'
+          end
+        when 'AWS::STS::UseGlobalEndpoint'
+          "context.config.sts_regional_endpoints == 'legacy'"
+        when 'AWS::S3::UseGlobalEndpoint'
+          "context.config.s3_us_east_1_regional_endpoint == 'legacy'"
+        when 'AWS::S3::Accelerate'
+          if @service.name == 'S3' || @service.name == 'S3Control'
+            'context[:use_accelerate_endpoint]'
+          else
+            'context.config.use_accelerate_endpoint'
+          end
+        when 'AWS::S3::ForcePathStyle'
+          'context.config.force_path_style'
+        when 'AWS::S3::UseArnRegion', 'AWS::S3Control::UseArnRegion'
+          'context.config.s3_use_arn_region'
+        when 'AWS::S3::DisableMultiRegionAccessPoints'
+          'context.config.s3_disable_multiregion_access_points'
+        when 'SDK::Endpoint'
+          'endpoint'
+        end
+      end
+
+      def context_param_value(operation, param_name)
+        return nil unless operation['input']
+
+        input_shape = operation['input']['shape']
+        members = @service.api['shapes'][input_shape].fetch('members', {})
+        members.detect do |(member_name, member)|
+          context_param = member.fetch('contextParam', {})
+          if context_param.fetch('name', nil) == param_name
+            break "context.params[:#{Underscore.underscore(member_name)}]"
+          end
+        end
+      end
+
+      def static_context_param(operation, param_name)
+        operation.fetch('staticContextParams', {})
+                 .fetch(param_name, {}).fetch('value', nil)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class EndpointsPlugin < View
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+        if (client_options = @service.api['clientContextParams'])
+          endpoint_parameters = @service.endpoint_rules.fetch('parameters', {})
+
+          @endpoint_options = client_options.each.with_object([]) do |(name, _data), array|
+            param_data = endpoint_parameters[name]
+
+            next if param_data['builtIn']
+
+            array << EndpointOption.new(
+              name: Underscore.underscore(name),
+              docstring: param_data['documentation'],
+              doc_type: param_data['type'],
+              default: param_data['default']
+            )
+          end
+        end
+        @endpoint_classes = @service.api['operations'].each.with_object([]) do
+          |(op, _api), array|
+          array << EndpointClass.new(
+            operation_name: Underscore.underscore(op),
+            class_name: op
+          )
+        end
+      end
+
+      # @return [Array<EndpointClass>]
+      attr_reader :endpoint_classes
+
+      # @return [Array<EndpointOption>, nil]
+      attr_reader :endpoint_options
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      def module_name
+        @service.module_name
+      end
+
+      class EndpointClass
+        def initialize(options)
+          @operation_name = options[:operation_name]
+          @class_name = options[:class_name]
+        end
+
+        # @return [String]
+        attr_reader :operation_name
+
+        # @return [String]
+        attr_reader :class_name
+      end
+
+      class EndpointOption
+        def initialize(options)
+          @name = options[:name]
+          @doc_type = options[:doc_type]
+          @default = options[:default].nil? ? 'nil' : options[:default]
+          @docstring = options[:docstring]
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [String]
+        attr_reader :doc_type
+
+        # @return [Boolean,String]
+        attr_reader :default
+
+        # @return [String]
+        attr_reader :docstring
+      end
+    end
+  end
+end

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

@@ -42,6 +42,10 @@ module AwsSdkCodeGenerator
         @custom ? false : true
       end
 
+      def files
+        ['LICENSE.txt', 'CHANGELOG.md', 'VERSION', 'lib/**/*.rb']
+      end
+
       # @return [String]
       def description
         if @custom

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

@@ -11,6 +11,7 @@ module AwsSdkCodeGenerator
       def initialize(options)
         @service = options.fetch(:service)
         @prefix = options.fetch(:prefix)
+        @codegenerated_plugins = options.fetch(:codegenerated_plugins)
       end
 
       # @return [String|nil]
@@ -56,7 +57,7 @@ module AwsSdkCodeGenerator
       # This is required to support backwards compatibility for SSO which was
       # moved from the aws-sdk-sso gem into aws-sdk-core.
       def require_core_guard?
-        name == 'SSO' || name == 'STS'
+        @service.included_in_core?
       end
 
       # @return [Array<String>]
@@ -64,10 +65,23 @@ module AwsSdkCodeGenerator
         paths = Set.new
         paths << "#{@prefix}/types"
         paths << "#{@prefix}/client_api"
+
+        # these must be required before the client
+        if @codegenerated_plugins
+          paths += @codegenerated_plugins.map { | p| p.path }
+        end
+
         paths << "#{@prefix}/client"
         paths << "#{@prefix}/errors"
         paths << "#{@prefix}/waiters" if @service.waiters
         paths << "#{@prefix}/resource"
+
+        unless @service.legacy_endpoints?
+          paths << "#{@prefix}/endpoint_parameters"
+          paths << "#{@prefix}/endpoint_provider"
+          paths << "#{@prefix}/endpoints"
+        end
+
         if @service.resources && @service.resources['resources']
           @service.resources['resources'].keys.each do |resource_name|
             path = "#{@prefix}/#{underscore(resource_name)}"