smithy 2.0.0.pre0 → 2.0.0.pre1

data/lib/smithy/views/client/endpoint_provider.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class EndpointProvider < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          service = @plan.service.values.first
+          @endpoint_rules = service['traits']['smithy.rules#endpointRuleSet']
+          @parameters = @endpoint_rules['parameters']
+                        .map { |id, data| EndpointParameter.new(id, data, @plan) }
+          @endpoint_function_bindings =
+            plan.welds.map(&:endpoint_function_bindings).reduce({}, :merge)
+          @assigned_variables = []
+          super()
+        end
+
+        attr_reader :parameters
+
+        def module_name
+          @plan.module_name
+        end
+
+        # TODO: simplify this by removing levels and just returning line strings
+        def endpoint_rules_code
+          res = StringIO.new
+          @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
+
+          res.string
+        end
+
+        private
+
+        def indent(str, levels = 3)
+          ('  ' * levels) + str
+        end
+
+        def endpoint_rule(rule, levels = 3)
+          if rule['conditions'] && !rule['conditions'].empty?
+            endpoint_rule_with_condition(levels, rule)
+          else
+            endpoint(rule['endpoint'], levels)
+          end
+        end
+
+        def endpoint_rule_with_condition(levels, rule)
+          res = StringIO.new
+          res << conditions(rule['conditions'], levels)
+          res << endpoint(rule['endpoint'], levels + 1)
+          res << indent("end\n", levels)
+          res.string
+        end
+
+        def endpoint(endpoint, levels)
+          res = StringIO.new
+          res << "return Smithy::Client::EndpointRules::Endpoint.new(uri: #{str(endpoint['url'])}"
+          res << ", headers: #{templated_hash_to_s(endpoint['headers'])}" if endpoint['headers']
+          res << ", properties: #{templated_hash_to_s(endpoint['properties'])}" if endpoint['properties']
+          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.transform_values do |v|
+            template_hash_value(v)
+          end
+        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, wrap: false)
+          else
+            value
+          end
+        end
+
+        def error_rule(rule, levels = 3)
+          if rule['conditions'] && !rule['conditions'].empty?
+            error_rule_with_condition(levels, rule)
+          else
+            error(rule['error'], levels)
+          end
+        end
+
+        def error_rule_with_condition(levels, rule)
+          res = StringIO.new
+          res << conditions(rule['conditions'], levels)
+          res << error(rule['error'], levels + 1)
+          res << indent("end\n", levels)
+          res.string
+        end
+
+        def error(error, levels)
+          indent("raise ArgumentError, #{str(error)}", levels)
+        end
+
+        def tree_rule(rule, levels = 3)
+          if rule['conditions'] && !rule['conditions'].empty?
+            tree_rule_with_condition(levels, rule)
+          else
+            tree_rules(rule['rules'], levels)
+          end
+        end
+
+        def tree_rule_with_condition(levels, rule)
+          res = StringIO.new
+          res << conditions(rule['conditions'], levels)
+          res << tree_rules(rule['rules'], levels + 1)
+          res << indent("end\n", levels)
+          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']
+            @assigned_variables << condition['assign']
+            "(#{condition['assign'].underscore} = #{function(condition)})"
+          else
+            function(condition)
+          end
+        end
+
+        def str(str)
+          if str.is_a?(Hash)
+            if str['ref']
+              variable(str['ref'])
+            elsif str['fn']
+              function(str)
+            else
+              raise "Unknown string type: #{str}"
+            end
+          else
+            template_str(str)
+          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 = variable(indexes.shift)
+          res + indexes.map do |index|
+            "['#{index}']"
+          end.join
+        end
+
+        def function(function)
+          args = function['argv'].map { |arg| fn_arg(arg) }.join(', ')
+          "#{fn_name(function['fn'])}(#{args})"
+        end
+
+        def fn_arg(arg)
+          if arg.is_a?(Hash)
+            if arg['ref']
+              variable(arg['ref'])
+            elsif arg['fn']
+              function(arg)
+            else
+              raise "Unexpected argument type: #{arg}"
+            end
+          elsif arg.is_a?(String)
+            template_str(arg)
+          else
+            arg
+          end
+        end
+
+        def variable(variable)
+          if @assigned_variables.include?(variable)
+            variable.underscore
+          else
+            "parameters.#{variable.underscore}"
+          end
+        end
+
+        def fn_name(function)
+          unless (binding = @endpoint_function_bindings[function])
+            raise ArgumentError, "No endpoint function binding registered for #{function}"
+          end
+
+          binding
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/endpoint_provider_rbs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class EndpointProviderRbs < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/endpoint_provider_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class EndpointProviderSpec < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          service = @plan.service.values.first
+          @operations = Model::ServiceIndex.new(@model).operations_for(@plan.service)
+          initialize_rules(service)
+          initialize_tests(service)
+          super()
+        end
+
+        attr_reader :parameters, :test_cases
+
+        def module_name
+          @plan.module_name
+        end
+
+        private
+
+        def initialize_rules(service)
+          @endpoint_rules = service['traits']['smithy.rules#endpointRuleSet']
+
+          @parameters = @endpoint_rules['parameters']
+                        .map { |id, data| EndpointParameter.new(id, data, @plan) }
+        end
+
+        def initialize_tests(service)
+          @endpoint_tests = service['traits']['smithy.rules#endpointTests'] || {}
+          @test_cases = @endpoint_tests['testCases']
+                        &.map { |data| EndpointTestCase.new(data, @plan, @operations) } || []
+        end
+
+        # @api private
+        class EndpointTestCase
+          def initialize(data, plan, operations)
+            @plan = plan
+            @documentation = data['documentation']
+            @expect = data['expect']
+            @operation_inputs = data.fetch('operationInputs', []).map do |d|
+              OperationInputsTest.new(d, plan, operations)
+            end
+            @params = (data['params'] || {})&.transform_keys do |key|
+              key.underscore.to_sym
+            end
+          end
+
+          attr_reader :documentation, :expect, :params, :operation_inputs
+
+          def expect_error?
+            !@expect['error'].nil?
+          end
+        end
+
+        # @api private
+        class OperationInputsTest
+          def initialize(data, plan, operations)
+            @operation_name = data['operationName'].underscore
+            @plan = plan
+            @model = plan.model
+            @service = @plan.service
+
+            input = find_input(data, operations)
+
+            @operation_params = build_operation_params(data, input)
+            @client_params  = build_client_params(data)
+          end
+
+          attr_reader :operation_name, :operation_params, :client_params
+
+          private
+
+          def build_client_params(data)
+            client_params = data.fetch('clientParams', {}).map do |k, v|
+              Param.new(k.underscore, v)
+            end
+
+            client_params + data.fetch('builtInParams', {}).map do |k, v|
+              built_in_to_param(k, v)
+            end.flatten
+          end
+
+          def build_operation_params(data, input)
+            data.fetch('operationParams', {}).map do |k, v|
+              member_shape = Model.shape(@model, input['members'][k]['target'])
+              Param.new(k.underscore, ShapeToHash.transform_value(@model, v, member_shape))
+            end
+          end
+
+          def find_input(data, operations)
+            input_target = operations.find do |k, _v|
+              k.split('#').last == data['operationName']
+            end.last['input']['target']
+            Model.shape(@model, input_target)
+          end
+
+          def built_in_bindings
+            @built_in_bindings ||=
+              @plan.welds
+                   .map(&:endpoint_built_in_bindings)
+                   .reduce({}, :merge)
+          end
+
+          def built_in_to_param(built_in, value)
+            built_in_bindings[built_in][:render_test_set]
+              .call(@plan, value)
+              .map { |k, v| Param.new(k, v) }
+          end
+        end
+
+        # @api private
+        class Param
+          def initialize(param, value, literal: false)
+            @param = param
+            @value = value
+            @literal = literal
+          end
+
+          attr_accessor :param
+
+          def value
+            if @value.is_a?(String) && !@literal
+              "'#{@value}'"
+            else
+              @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/errors.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Errors < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def errors
+          Model::ServiceIndex
+            .new(@model)
+            .shapes_for(@plan.service)
+            .select { |_key, shape| shape.fetch('traits', {}).any? { |id, _trait| id == 'smithy.api#error' } }
+            .map { |id, structure| Error.new(id, structure) }
+        end
+
+        # @api private
+        class Error
+          def initialize(id, structure)
+            @id = id
+            @structure = structure
+          end
+
+          def docstrings
+            @structure
+              .fetch('traits', {})
+              .fetch('smithy.api#documentation', "Error class for #{name}.")
+              .split("\n")
+          end
+
+          def name
+            Model::Shape.name(@id).camelize
+          end
+
+          def retryable?
+            @structure
+              .dig('traits', 'smithy.api#retryable') != nil
+          end
+
+          def throttling?
+            @structure
+              .fetch('traits', {})
+              .fetch('smithy.api#retryable', {})
+              .fetch('throttling', false)
+          end
+
+          def members
+            @structure['members'].map { |name, member| Member.new(name, member) }
+          end
+
+          # @api private
+          class Member
+            def initialize(name, shape)
+              @name = name
+              @shape = shape
+            end
+
+            attr_reader :shape
+
+            def message?
+              @name == 'message'
+            end
+
+            def docstrings
+              @shape
+                .fetch('traits', {})
+                .fetch('smithy.api#documentation', '')
+                .split("\n")
+            end
+
+            def name
+              @name.underscore
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/errors_rbs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class ErrorsRbs < Errors
+        attr_reader :model
+      end
+    end
+  end
+end

data/lib/smithy/views/client/gemspec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Gemspec < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def gem_name
+          @plan.gem_name
+        end
+
+        def gem_version
+          @plan.gem_version
+        end
+
+        def dependencies
+          dependencies = @plan.welds.map(&:add_dependencies).reduce({}, :merge)
+          dependencies = dependencies.except(@plan.welds.map(&:remove_dependencies).reduce([], :+))
+          dependencies.merge!(
+            if @plan.type == :schema
+              { 'smithy-schema' => '~> 1' }
+            else
+              { 'smithy-client' => '~> 1' }
+            end
+          )
+          dependencies
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/module.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class Module < View
+        def initialize(plan)
+          @plan = plan
+          _, service = plan.service.first
+          @traits = service.fetch('traits', {})
+          @model = plan.model
+          super()
+        end
+
+        def requires
+          requires = @plan.welds.map(&:add_dependencies).reduce({}, :merge)
+          requires = requires.except(@plan.welds.map(&:remove_dependencies).reduce([], :+))
+          requires = requires.keys
+          requires <<
+            if @plan.type == :schema
+              'smithy-schema'
+            else
+              'smithy-client'
+            end
+          requires
+        end
+
+        def module_names
+          @plan.module_name.split('::')
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def docstrings
+          lines = []
+          lines.concat(title_docstrings)
+          lines.concat(documentation_docstrings)
+          lines.concat(deprecated_docstrings)
+          lines.concat(external_documentation_docstrings)
+          lines.concat(since_docstrings)
+          lines.concat(unstable_docstrings)
+          lines
+        end
+
+        def gem_version
+          @plan.gem_version
+        end
+
+        def gem_name
+          @plan.gem_name
+        end
+
+        def relative_requires
+          return [] unless @plan.destination_root
+          # types must come before schemas
+          return %i[customizations types schema] if @plan.type == :schema
+
+          # paginators must come before schemas
+          %w[types paginators schema auth_parameters auth_resolver client customizations errors endpoint_parameters
+             endpoint_provider waiters]
+        end
+
+        private
+
+        def title_docstrings
+          return [] unless @traits.key?('smithy.api#title')
+
+          [Model::YARD.title_docstring(@traits['smithy.api#title'])]
+        end
+
+        def documentation_docstrings
+          @traits.fetch('smithy.api#documentation', '').split("\n")
+        end
+
+        def deprecated_docstrings
+          return [] unless @traits.key?('smithy.api#deprecated')
+
+          message = @traits['smithy.api#deprecated'].fetch('message', '')
+          since = @traits['smithy.api#deprecated'].fetch('since', '')
+          Model::YARD.deprecated_docstrings(message, since)
+        end
+
+        def external_documentation_docstrings
+          return [] unless @traits.key?('smithy.api#externalDocumentation')
+
+          hash = @traits.fetch('smithy.api#externalDocumentation', {})
+          Model::YARD.external_documentation_docstrings(hash)
+        end
+
+        def since_docstrings
+          return [] unless @traits.key?('smithy.api#since')
+
+          [Model::YARD.since_docstring(@traits['smithy.api#since'])]
+        end
+
+        def unstable_docstrings
+          return [] unless @traits.key?('smithy.api#unstable')
+
+          [Model::YARD.unstable_docstring]
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/module_rbs.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class ModuleRbs < View
+        def initialize(plan)
+          @plan = plan
+          @model = plan.model
+          super()
+        end
+
+        def module_names
+          @plan.module_name.split('::')
+        end
+      end
+    end
+  end
+end