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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f47bca9edb4689814cec21486fbc9924716462ea8dc0cf69e05d82b11c95d3b
-  data.tar.gz: 7173e29d52ac6118968e30d35e750cfe2a702e9c4a320041c46ab534f6c5d018
+  metadata.gz: b4bb64ca30811529d0c5c4149e3d46b7eabef0d3068672ca06ed6d9fc97369f5
+  data.tar.gz: c2e56887b3686a58569da5fa643a8cb69bcca35c4b0f24dbdd67e48c3d3675c8
 SHA512:
-  metadata.gz: c009d5dec4abd1d587254c564eeb88c89bd08d687070ae539ea4ea0fc64d747edc8b28641f7544ea9860363aa7467a631fae896d815cde99cc3502c7b7b844e2
-  data.tar.gz: b195875c8e9dd16ba6373784bd786dc79663a6e0f421c2835462cd1bccc407e2168d5a98947bffa6fc31ea1eb65ba27fca67047c83ef2a9d65987e4dbd3902d0
+  metadata.gz: 3a6b20c93b4c58ef3bfac9e2d48551540106fa907deb17b72bb00876c807a2dbf05079b38634534a18a563a6f0b6affd98564a94a16370ba4e3d7efcf34a1034
+  data.tar.gz: 63b927d59a16241bc32e5ec51d647ae6dcc952c562e9eedccf50451bf62a64065d3833be2b8b0d7ffef6114300068b426bf3a96617c0c97f8bb9932b3ff45605

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

@@ -26,8 +26,227 @@ module AwsSdkCodeGenerator
         @service.module_name
       end
 
-      def endpoint_rules_encoded
-        Base64.encode64(JSON.dump(@endpoint_rules))
+      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

data/templates/endpoint_provider_class.mustache

@@ -5,26 +5,8 @@
 {{/generated_src_warning}}
 module {{module_name}}
   class EndpointProvider
-    def initialize(rule_set = nil)
-      @@rule_set ||= begin
-        endpoint_rules = Aws::Json.load(Base64.decode64(RULES))
-        Aws::Endpoints::RuleSet.new(
-          version: endpoint_rules['version'],
-          service_id: endpoint_rules['serviceId'],
-          parameters: endpoint_rules['parameters'],
-          rules: endpoint_rules['rules']
-        )
-      end
-      @provider = Aws::Endpoints::RulesProvider.new(rule_set || @@rule_set)
-    end
-
     def resolve_endpoint(parameters)
-      @provider.resolve_endpoint(parameters)
+{{{ endpoint_rules_code }}}
     end
-
-    # @api private
-    RULES = <<-JSON
-{{endpoint_rules_encoded}}
-    JSON
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-code-generator
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre
+  version: 0.4.0.pre
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kramdown