aws-sdk-resources 2.11.412 → 3.67.0

data/lib/aws-sdk-resources/batch.rb

@@ -1,143 +0,0 @@
-module Aws
-  module Resources
-
-    # A batch provides array like access to a list of resources. Batches
-    # also provide the ability to invoke certain operations against
-    # the entire batch.
-    #
-    # ## Getting a Batch
-    #
-    # You should normally not need to construct a batch. Anywhere a list
-    # of resources is returned, they are returned as a batch:
-    #
-    #     # security_groups is a batch
-    #     security_groups = ec2.instance('i-12345678').security_groups
-    #
-    # When the possible number of resources is unknown or large, the
-    # resources will be returned in a collection. Collections can enumerate
-    # individual resources or batches. They manage paging over the
-    # AWS request/responses to produce batches.
-    #
-    #     # objects is a collection
-    #     objects = s3.bucket('aws-sdk').objects
-    #
-    # You can invoke batch operations against collections and they will
-    # invoke them on each batch.
-    #
-    #     # delete all objects in this bucket in batches of 1k
-    #     objects = s3.bucket('aws-sdk').objects
-    #     objects.delete
-    #
-    # ## Batch Operations
-    #
-    # Batches provide operations that operate on the entire batch. These
-    # operations are only defined for resources where the AWS API accepts
-    # multiple inputs. This means a batch operation for n resources will
-    # only make one request.
-    #
-    # Resource classes document each of their own batch operations.
-    # See {S3::Object} for an example.
-    #
-    class Batch
-
-      include Enumerable
-
-      # @param [Array<Resource>] resources
-      # @option options [Seahorse::Client::Response] :response
-      def initialize(resource_class, resources, options = {})
-        @resource_class = resource_class
-        @resources = resources
-        @response = options[:response]
-        @size = resources.size
-        @options = options
-      end
-
-      # @return [Class<Resource>]
-      attr_reader :resource_class
-
-      # @return [Seahorse::Client::Response, nil]
-      attr_reader :response
-
-      # @return [Integer]
-      attr_reader :size
-
-      alias count size
-
-      # @param [Integer] index
-      # @return [Resource]
-      def [](index)
-        @resources[index]
-      end
-
-      # Yields each resource of the batch, one at a time.
-      def each(&block)
-        enum = @resources.to_enum
-        enum.each(&block) if block_given?
-        enum
-      end
-
-      # @param [Integer] count
-      # @return [Resource, Batch]
-      def first(count = nil)
-        if count
-          self.class.new(@resource_class, @resources.first(count), @options)
-        else
-          @resources.first
-        end
-      end
-
-      # @return [Boolean]
-      def empty?
-        @resources.empty?
-      end
-
-      # @api private
-      def inspect
-        "#<#{self.class.name} resources=#{@resources.inspect}>"
-      end
-
-      # @api private
-      def respond_to?(method_name, *args)
-        if @resource_class.batch_operation_names.include?(method_name.to_sym)
-          true
-        else
-          super
-        end
-      end
-
-      # @api private
-      def method_missing(method_name, *args, &block)
-        if respond_to?(method_name)
-          invoke_batch_operation(method_name, args, block) unless empty?
-        else
-          super
-        end
-      end
-
-      private
-
-      def invoke_batch_operation(method_name, args, block)
-        self.class.validate_batch_args!(args)
-        operation = @resource_class.batch_operation(method_name)
-        operation.call(resource:self, args:args, block:block)
-      end
-
-      class << self
-
-        # @api private
-        def validate_batch_args!(args)
-          case args.count
-          when 0
-          when 1
-            unless Hash === args.first
-              raise ArgumentError, "expected options to be a hash"
-            end
-          else
-            raise ArgumentError, "wrong number of arguments, expected 0 or 1"
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/aws-sdk-resources/builder.rb

@@ -1,85 +0,0 @@
-module Aws
-  module Resources
-
-    # A {Builder} construct resource objects.  It extracts resource identifiers
-    # for the objects it builds from another resource object and/or an
-    # AWS response.
-    class Builder
-
-      include Options
-
-      # @option options [required, Class<Resource>] resource_class
-      # @option options [Array<BuilderSources::Source>] :sources ([])
-      def initialize(options = {})
-        @resource_class = options[:resource_class]
-        @sources = options[:sources] || []
-      end
-
-      # @return [Class<Resource>]
-      attr_reader :resource_class
-
-      # @return [Array<BuilderSources::Source>] A list of resource
-      #   identifier sources.
-      attr_reader :sources
-
-      # @return [Boolean] Returns `true` if this builder returns an array
-      #   of resource objects from {#build}.
-      def plural?
-        @sources.any?(&:plural?)
-      end
-
-      # @option [Resource] :resource
-      # @option [Seahorse::Client::Response] :response
-      # @return [Resource, Array<Resource>] Returns a resource object or an
-      #   array of resource objects if {#plural?}.
-      def build(options = {})
-        identifier_map = @sources.each.with_object({}) do |source, hash|
-          hash[source.target] = source.extract(options)
-        end
-        if plural?
-          build_batch(identifier_map, options)
-        else
-          build_one(identifier_map, options)
-        end
-      end
-
-      private
-
-      def build_batch(identifier_map, options, &block)
-        resources = (0...resource_count(identifier_map)).collect do |n|
-          identifiers = @sources.inject({}) do |hash, source|
-            value = identifier_map[source.target]
-            value = value[n] if source.plural?
-            hash[source.target] = value
-            hash
-          end
-          resource = build_one(identifiers, options)
-          yield(resource) if block_given?
-          resource
-        end
-        Batch.new(resource_class, resources, options)
-      end
-
-      def build_one(identifiers, options)
-        if identifiers.count > 0 && identifiers.values.any?(&:nil?)
-          nil
-        else
-          @resource_class.new(identifiers.merge(
-            client: client(options)
-          ))
-        end
-      end
-
-      def resource_count(identifier_map)
-        identifier_map.values.inject(0) do |max, values|
-          [max, values.is_a?(Array) ? values.size : 0].max
-        end
-      end
-
-      def client(options)
-        Array(options[:resource]).first.client
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-resources/builder_sources.rb

@@ -1,105 +0,0 @@
-module Aws
-  module Resources
-    module BuilderSources
-
-      module Source
-
-        def initialize(options)
-          @source = options[:source]
-          @target = options[:target].to_sym
-        end
-
-        # @return [String, nil]
-        attr_reader :source
-
-        # @return [Symbol]
-        attr_reader :target
-
-        # @return [Boolean]
-        def plural?
-          !!(@source && @source.include?('['))
-        end
-
-      end
-
-      class Argument
-
-        include Source
-
-        # @option [required, String] :argument
-        def extract(options)
-          (options[:args] || [])[@source]
-        end
-
-        def plural?
-          false
-        end
-
-      end
-
-      # Extracts an identifier from a parent resource identifier.  Used
-      # when building a {Resource} from the context of another resource.
-      class Identifier
-
-        include Source
-
-        # @option [required, Resource] :resource
-        def extract(options)
-          options[:resource].send(@source)
-        end
-
-      end
-
-      # Extracts an identifier from the data of a parent resource.  Used
-      # when building a {Resource} from the context of another resource.
-      class DataMember
-
-        include Source
-
-        # @option [required, Resource] :resource
-        def extract(options)
-          JMESPath.search(@source, options[:resource].data)
-        end
-
-      end
-
-      # Extracts an identifier from the request parameters used to generate
-      # a response.  Used when building a {Resource} object from the response
-      # of an operation.
-      class RequestParameter
-
-        include Source
-
-        # @option [required, Seahorse::Client::Response] :response
-        def extract(options)
-          JMESPath.search(@source, options[:response].context.params)
-        end
-
-      end
-
-      # Extracts an identifier from the data of a response.  Used when
-      # building a {Resource} object from the response of an operation.
-      class ResponsePath
-
-        include Source
-
-        # @option [required, Seahorse::Client::Response] :response
-        def extract(options)
-          JMESPath.search(@source, options[:response].data)
-        end
-
-      end
-
-      # Supplies a string literal.
-      class StringLiteral
-
-        include Source
-
-        def extract(options)
-          @source
-        end
-
-      end
-    end
-  end
-end

data/lib/aws-sdk-resources/collection.rb

@@ -1,107 +0,0 @@
-module Aws
-  module Resources
-    class Collection
-
-      include Enumerable
-
-      # @param [HasManyOperation] operation
-      # @option (see HasManyOperation#call)
-      # @api private
-      def initialize(operation, options)
-        @operation = operation
-        @options = options
-      end
-
-      # @return [Enumerator<Resource>]
-      def each(&block)
-        if block_given?
-          batches.each { |batch| batch.each(&block) }
-        else
-          self
-        end
-      end
-
-      # @api private
-      # @return [Enumerator<Batch>]
-      def batches(&block)
-        @operation.batches(@options)
-      end
-
-      # Specifies the maximum number of items to enumerate.
-      #
-      #     collection.limit(10).each do |resource|
-      #       # yields at most 10 times
-      #     end
-      #
-      # @param [Integer] limit The maximum number of items to yield
-      #   via {#each} or {#batches}.
-      # @return [Collection]
-      def limit(limit)
-        self.class.new(@operation, @options.merge(limit: limit))
-      end
-
-      # Returns the first resource from the collection.
-      #
-      #     resource = collection.first
-      #
-      # If you pass a count, then the first `count` resources are returned in
-      # a single batch. See the resource specific batch documentation for
-      # a list of supported batch methods.
-      #
-      #     resources = collection.first(10)
-      #     resources.delete
-      #
-      # @return [Resource, Batch]
-      def first(count = 1)
-        if count == 1
-          limit(1).to_a.first
-        else
-          Batch.new(resource_class, limit(count).to_a)
-        end
-      end
-
-      # @api private
-      def respond_to?(method_name, *args)
-        if resource_class.batch_operation_names.include?(method_name.to_sym)
-          true
-        else
-          super
-        end
-      end
-
-      # @api private
-      def method_missing(method_name, *args, &block)
-        if respond_to?(method_name)
-          Batch.validate_batch_args!(args)
-          batches.each do |batch|
-            batch.send(method_name, *args, &block)
-          end
-        else
-          super
-        end
-      end
-
-      # @api private
-      def inspect
-        parts = {}
-        parts[:type] = resource_class.name
-        parts[:limit] = @options[:limit]
-        parts[:params] = @options[:params] || {}
-        parts = parts.inject("") {|s,(k,v)| s << " #{k}=#{v.inspect}" }
-        ['#<', self.class.name, parts, '>'].join
-      end
-
-      private
-
-      # @api private
-      def limit_key
-        @operation.limit_key
-      end
-
-      def resource_class
-        @operation.builder.resource_class
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-resources/definition.rb

@@ -1,331 +0,0 @@
-require 'set'
-
-module Aws
-  module Resources
-
-    # Given a resource definition document, a {Definition} can build a set
-    # of related resource classes.
-    class Definition
-
-      # @param [Hash] definition
-      # @option options [String] :source_path
-      def initialize(definition = {}, options = {})
-        @source = definition
-        @source_path = options[:source_path]
-      end
-
-      # @param [Module<Service>] namespace
-      # @return [void]
-      def apply(namespace)
-        build_resource_classes(namespace)
-        each_resource_class(namespace) do |resource, definition|
-          define_load(namespace, resource, definition['load'])
-          define_actions(namespace, resource, definition['actions'] || {})
-          define_batch_actions(namespace, resource, definition['batchActions'] || {})
-          define_waiters(namespace, resource, definition['waiters'] || {})
-          define_has(namespace, resource, definition['has'] || {})
-          define_has_many(namespace, resource, definition['hasMany'] || {})
-          define_data_attributes(namespace, resource, definition)
-        end
-      end
-
-      private
-
-      def build_resource_classes(namespace)
-        each_definition do |name, definition|
-          resource_class = Class.new(Resource)
-          resource_class.client_class = namespace::Client
-          resource_class.resource_name = name
-          (definition['identifiers'] || []).each do |identifier|
-            resource_class.add_identifier(underscore(identifier['name']))
-          end
-          namespace.const_set(name, resource_class)
-        end
-      end
-
-      def each_resource_class(namespace, &block)
-        each_definition do |name, definition|
-          yield(namespace.const_get(name), definition)
-        end
-      end
-
-      def define_batch_actions(namespace, resource, batch_actions)
-        batch_actions.each do |name, definition|
-          method_name = "batch_" + underscore(name)
-          method_name += '!' if dangerous?(name, definition)
-          operation = build_operation(namespace, resource, definition)
-          resource.add_batch_operation(method_name, operation)
-        end
-      end
-
-      def dangerous?(name, definition)
-        if
-          name.match(/delete/i) ||
-          name.match(/terminate/i) ||
-          definition['request']['operation'].match(/delete/i) ||
-          definition['request']['operation'].match(/terminate/i)
-        then
-          true
-        else
-          false
-        end
-      end
-
-      def define_data_attributes(namespace, resource, definition)
-        if shape_name = definition['shape']
-          shape = resource.client_class.api.metadata['shapes'][shape_name]
-          shape.member_names.each do |member_name|
-            if
-              resource.instance_methods.include?(member_name) ||
-              data_attribute_is_an_identifier?(member_name, resource, definition)
-            then
-              next # some data attributes are duplicates to identifiers
-            else
-              resource.add_data_attribute(member_name)
-            end
-          end
-        end
-      end
-
-      def data_attribute_is_an_identifier?(attr_name, resource, definition)
-        resource.identifiers.include?(attr_name) ||
-        definition['identifiers'].any? { |i| underscore(i['dataMember']) == attr_name.to_s }
-      end
-
-      def define_load(namespace, resource, definition)
-        return unless definition
-        resource.load_operation = Operations::LoadOperation.new(
-          request: define_request(definition['request']),
-          path: underscore(definition['path']),
-          source: source(definition),
-        )
-      end
-
-      def define_actions(namespace, resource, actions)
-        actions.each do |name, action|
-          operation = build_operation(namespace, resource, action)
-          resource.add_operation(underscore(name), operation)
-        end
-      end
-
-      def define_waiters(namespace, resource, waiters)
-        waiters.each do |name, definition|
-          operation = build_waiter_operation(namespace, resource, definition)
-          resource.add_operation("wait_until_#{underscore(name)}", operation)
-        end
-      end
-
-      def build_operation(namespace, resource, definition)
-        if definition['resource']
-          build_resource_action(namespace, resource, definition)
-        else
-          build_basic_action(namespace, resource, definition)
-        end
-      end
-
-      def build_basic_action(namespace, resource, definition)
-        Operations::Operation.new(
-          request: define_request(definition['request']),
-          source: source(definition)
-        )
-      end
-
-      def build_resource_action(namespace, resource, definition)
-        builder = define_builder(namespace, definition['resource'])
-        if path = definition['resource']['path']
-          builder.sources << BuilderSources::ResponsePath.new({
-            source: underscore(path),
-            target: :data,
-          })
-        end
-        Operations::ResourceOperation.new(
-          request: define_request(definition['request']),
-          builder: builder,
-          source: source(definition)
-        )
-      end
-
-      def has_many(namespace, resource, definition)
-        builder = define_builder(namespace, definition['resource'])
-        if path = definition['resource']['path']
-          builder.sources << BuilderSources::ResponsePath.new({
-            source: underscore(path),
-            target: :data,
-          })
-        end
-        Operations::HasManyOperation.new(
-          request: define_request(definition['request']),
-          builder: builder,
-          source: source(definition),
-          limit_key: limit_key(resource, definition))
-      end
-
-      def build_waiter_operation(namespace, resource, definition)
-        Operations::WaiterOperation.new(
-          waiter_name: underscore(definition['waiterName']).to_sym,
-          waiter_params: request_params(definition['params']),
-          path: underscore(definition['path'])
-        )
-      end
-
-      def limit_key(resource, definition)
-        operation_name = definition['request']['operation']
-        operation = resource.client_class.api.operation(underscore(operation_name))
-        if operation[:pager]
-          operation[:pager].limit_key
-        else
-          nil
-        end
-      end
-
-      def define_request(definition)
-        Request.new(
-          method_name: underscore(definition['operation']),
-          params: request_params(definition['params'] || [])
-        )
-      end
-
-      def request_params(params)
-        params.map do |definition|
-          send("#{definition['source']}_request_param", definition)
-        end
-      end
-
-      def identifier_request_param(definition)
-        RequestParams::Identifier.new({
-          target: underscore(definition['target']),
-          name: underscore(definition['name']).to_sym,
-        })
-      end
-
-      def data_request_param(definition)
-        RequestParams::DataMember.new({
-          target: underscore(definition['target']),
-          path: underscore(definition['path']),
-        })
-      end
-
-      def string_request_param(definition)
-        RequestParams::Literal.new({
-          target: underscore(definition['target']),
-          value: definition['value'],
-        })
-      end
-      alias integer_request_param string_request_param
-      alias float_request_param string_request_param
-      alias boolean_request_param string_request_param
-      alias null_request_param string_request_param
-
-      def define_has_many(namespace, resource, has_many)
-        has_many.each do |name, definition|
-          operation = has_many(namespace, resource, definition)
-          resource.add_operation(underscore(name), operation)
-        end
-      end
-
-      def define_has(namespace, resource, has)
-        has.each do |name, definition|
-          has_operation(namespace, resource, name, definition)
-        end
-      end
-
-      def has_operation(namespace, resource, name, definition)
-        builder = define_builder(namespace, definition['resource'])
-        if path = definition['resource']['path']
-          builder.sources << BuilderSources::DataMember.new({
-            source: underscore(path),
-            target: :data,
-          })
-        end
-        operation = Operations::HasOperation.new(
-          builder: builder,
-          source: source(definition))
-        resource.add_operation(underscore(name), operation)
-      end
-
-      def define_builder(namespace, definition)
-        Builder.new(
-          resource_class: namespace.const_get(definition['type']),
-          sources: builder_sources(definition['identifiers'] || [])
-        )
-      end
-
-      def builder_sources(sources)
-        sources.map do |definition|
-          send("#{definition['source']}_builder_source", definition, sources)
-        end
-      end
-
-      def input_builder_source(definition, sources)
-        arguments = sources.select { |s| s['source'] == 'input' }
-        BuilderSources::Argument.new({
-          source: arguments.index(definition),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def identifier_builder_source(definition, _)
-        BuilderSources::Identifier.new({
-          source: underscore(definition['name']),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def data_builder_source(definition, _)
-        BuilderSources::DataMember.new({
-          source: underscore(definition['path']),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def requestParameter_builder_source(definition, _)
-        BuilderSources::RequestParameter.new({
-          source: underscore(definition['path']),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def response_builder_source(definition, _)
-        BuilderSources::ResponsePath.new({
-          source: underscore(definition['path']),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def string_builder_source(definition, _)
-        BuilderSources::ResponsePath.new({
-          source: underscore(definition['value']),
-          target: underscore(definition['target']),
-        })
-      end
-
-      def svc_definition
-        @source['service'] || {}
-      end
-
-      def resource_definitions
-        @source['resources'] || {}
-      end
-
-      def each_definition(&block)
-        yield('Resource', svc_definition)
-        resource_definitions.each(&block)
-      end
-
-      def underscore(str)
-        if str
-          str.gsub(/\w+/) { |part| Seahorse::Util.underscore(part) }
-        end
-      end
-
-      def source(definition)
-        if ENV['SOURCE']
-          Source.new(definition, @source_path)
-        else
-          nil
-        end
-      end
-
-    end
-  end
-end