aws-sdk-resources 2.0.0.pre

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

@@ -0,0 +1,15 @@
+module Aws
+  module Resources
+    module Errors
+
+      class UnknownOperationError < ArgumentError
+        def initialize(name)
+          super("operation `#{name}' not defined")
+        end
+      end
+
+      class DefinitionError < ArgumentError; end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Aws
+  module Resources
+    module OperationMethods
+
+      # @param [Symbol] name
+      # @return [Operation] Returns the named operation.
+      # @raise [Errors::UnknownOperationError]
+      def operation(name)
+        @operations[name.to_sym] or
+          raise Errors::UnknownOperationError.new(name)
+      end
+
+      # @param [Symbol] method_name
+      # @param [Operation] operation
+      # @return [void]
+      def add_operation(method_name, operation = nil, &definition)
+        operation = definition if block_given?
+        safe_define_method(method_name) do |*args, &block|
+          operation.call(resource:self, args:args, block:block)
+        end
+        @operations[method_name.to_sym] = operation
+      end
+
+      # @return [Hash]
+      def operations(&block)
+        @operations.dup
+      end
+
+      # @return [Array<Symbol>]
+      def operation_names
+        @operations.keys
+      end
+
+      # @api private
+      def inherited(subclass)
+        subclass.send(:instance_variable_set, "@operations", {})
+      end
+
+      private
+
+      def safe_define_method(method_name, &block)
+        if instance_methods.include?(method_name.to_sym)
+          msg = "unable to define method #{name}##{method_name}, "
+          msg << "method already exists"
+          raise Errors::DefinitionError, msg
+        else
+          define_method(method_name, &block)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,294 @@
+require 'jamespath'
+
+module Aws
+  module Resources
+    module Operations
+
+      # Base class for operations. An operation is any object that responds
+      # to {#call} receiving a hash of options including:
+      #
+      # * `:resource` - The resource object the operation is invoked against.
+      # * `:args` - An array of arguments given by the caller
+      # * `:block` - An optional block argument
+      #
+      class Base
+
+        include Options
+
+        def initialize(options = {})
+          @source = options[:source]
+        end
+
+        # @return [Source, nil]
+        attr_reader :source
+
+        # @option options[required,Resource] :resource
+        # @option options[required,Array<Mixed>] :args
+        # @option options[Proc] :block
+        # @return [Mixed]
+        def call(options = {})
+          raise NotImplementedError
+        end
+
+      end
+
+      # Makes an API request using the resource client, returning the client
+      # response.  Most operation classes extend this basic operation.
+      class Operation < Base
+
+        # @option options [required, Request] :request
+        def initialize(options = {})
+          @request = option(:request, options)
+          super
+        end
+
+        # @return [Request]
+        attr_reader :request
+
+        # @option (see Base#call)
+        # @return [Seahorse::Client::Response]
+        def call(options)
+          @request.call(options)
+        end
+
+      end
+
+      class DataOperation < Operation
+
+        # @option options [required, Request] :request
+        # @option options [required, String<JMESPath>] :path
+        def initialize(options = {})
+          @path = option(:path, options)
+          super
+        end
+
+        # @return [String<JMESPath>]
+        attr_reader :path
+
+        # @option (see Base#call)
+        # @return [Object] Returns the value resolved to by {#path}.
+        def call(options)
+          extract(super)
+        end
+
+        private
+
+        def extract(resp)
+          @path == '$' ? resp.data : Jamespath.search(@path, resp.data)
+        end
+
+      end
+
+      class EnumerateDataOperation < DataOperation
+
+        # @option options [required, Request] :request
+        # @option options [required, String<JMESPath>] :path
+        # @option options [Symbol] :limit_key
+        def initialize(options = {})
+          @limit_key = options[:limit_key]
+          super
+        end
+
+        # @option (see Base#call)
+        # @option options [Integer] :limit (nil)
+        # @return [Enumerator]
+        def call(options)
+          if options[:limit]
+            enum_for(:limited_each, options[:limit], options)
+          else
+            enum_for(:each, options)
+          end
+        end
+
+        private
+
+        def each(options, &block)
+          @request.call(options).each do |response|
+            extract(response).each(&block)
+          end
+        end
+
+        def limited_each(limit, options, &block)
+          yielded = 0
+          each(options) do |value|
+            yield(value)
+            yielded += 1
+            break if yielded == limit
+          end
+        end
+
+      end
+
+      class ResourceOperation < Operation
+
+        # @option options [required, Request] :request
+        # @option options [required, Builder] :builder
+        def initialize(options = {})
+          @builder = option(:builder, options)
+          super
+        end
+
+        # @return [Builder]
+        attr_reader :builder
+
+        # @option (see Base#call)
+        # @return [Resource, Array<Resource>]
+        def call(options)
+          @builder.build(options.merge(response:super))
+        end
+
+      end
+
+      class EnumerateResourceOperation < ResourceOperation
+
+        # @option options [required, Request] :request
+        # @option options [required, Builder] :builder
+        # @option options [Symbol] :limit_key
+        def initialize(options)
+          @limit_key = options[:limit_key]
+          super
+        end
+
+        # @return [Builder]
+        attr_reader :builder
+
+        # @return [Symbol, nil]
+        attr_reader :limit_key
+
+        # @option (see Base#call)
+        # @return [Collection]
+        def call(options)
+          Collection.new(self, options)
+        end
+
+        # @api private
+        # @return [Enumerator<Batch>]
+        def batches(options, &block)
+          if options[:limit]
+            enum_for(:limited_batches, options[:limit], options, &block)
+          else
+            enum_for(:all_batches, options, &block)
+          end
+        end
+
+        private
+
+        def all_batches(options, &block)
+          options = apply_batch_size(options)
+          @request.call(options).each do |response|
+            yield(@builder.build(options.merge(response:response)))
+          end
+        end
+
+        def limited_batches(limit, options, &block)
+          remaining = limit
+          all_batches(options) do |batch|
+            if batch.size < remaining
+              yield(batch)
+              remaining -= batch.size
+            else
+              yield(batch.first(remaining))
+              break
+            end
+          end
+        end
+
+        def apply_batch_size(options)
+          if batch_size = options[:batch_size]
+            params = (options[:params] || {}).merge(limit_key => batch_size)
+            options.merge(params: params)
+          else
+            options
+          end
+        end
+
+      end
+
+      class ReferenceOperation < Base
+
+        # @option options [required, Builder] :builder
+        def initialize(options = {})
+          @builder = option(:builder, options)
+          super
+        end
+
+        # @return [Builder]
+        attr_reader :builder
+
+        # @option (see Base#call)
+        # @return [Resource]
+        def call(options)
+          if argc(options) == arity
+            @builder.build(options)
+          else
+            msg = "wrong number of arguments (#{argc(options)} for #{arity})"
+            raise ArgumentError, msg
+          end
+        end
+
+        def arity
+          @builder.sources.count { |s| BuilderSources::Argument === s }
+        end
+
+        private
+
+        def argc(options)
+          (options[:args] || []).count
+        end
+
+      end
+
+      class WaiterOperation < Base
+
+        include Options
+
+        def initialize(options = {})
+          @waiter_name = option(:waiter_name, options)
+          @waiter_params = option(:waiter_params, options)
+          @path = options[:path]
+          super
+        end
+
+        # @return [Symbol]
+        attr_reader :waiter_name
+
+        # @return [Array<RequestParams::Base>]
+        attr_reader :waiter_params
+
+        # @return [String<JMESPathExpression>, nil]
+        attr_reader :path
+
+        # @option options [required,Resource] :resource
+        # @option options [required,Array<Mixed>] :args
+        def call(options, &block)
+
+          resource = options[:resource]
+
+          params_hash = {}
+          @waiter_params.each do |param|
+            param.apply(params_hash, options)
+          end
+
+          user_params = options[:params] || {}
+          params = deep_merge(user_params, params_hash)
+          resp = resource.client.wait_until(@waiter_name, params)
+
+          resource_opts = resource.identifiers.dup
+          resource_opts[:data] = Jamespath.search(@path, resp.data) if @path
+          resource_opts[:client] = resource.client
+          resource.class.new(resource_opts)
+        end
+
+        def deep_merge(obj1, obj2)
+          case obj1
+          when Hash then obj1.merge(obj2) { |key, v1, v2| deep_merge(v1, v2) }
+          when Array then obj2 + obj1
+          else obj2
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Aws
+  module Resources
+    module Options
+
+      private
+
+      def expect_hash(key, options)
+        if options.key?(key) && !(Hash === options[key])
+          raise ArgumentError, "expected #{key.inspect} to be a Hash"
+        end
+      end
+
+      def option(key, options)
+        if options[key].nil?
+          raise Errors::DefinitionError, "missing required option #{key.inspect}"
+        else
+          options[key]
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Aws
+  module Resources
+    class Request
+
+      # @option opitons [requried, String] :method_name
+      # @option options [Array<RequestParams::Param>] :params ([]) A list of
+      #   request params to apply to the request when called.
+      def initialize(options = {})
+        @method_name = options[:method_name]
+        @params = options[:params] || []
+      end
+
+      # @return [String] Name of the method called on the client when this
+      #   operation is called.
+      attr_reader :method_name
+
+      # @return [Array<RequestParams::Param>]
+      attr_reader :params
+
+      # @option options [required,Resource] :resource
+      # @option options [Array<Mixed>] :args
+      # @return [Seahorse::Client::Response]
+      def call(options)
+        client(options).send(@method_name, req_params(options), &options[:block])
+      end
+
+      private
+
+      def client(options)
+        Array(options[:resource]).first.client
+      end
+
+      def req_params(options)
+        RequestParams::ParamsHash.new(@params).build(options)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+module Aws
+  module Resources
+    module RequestParams
+
+      # @api private
+      class ParamsHash
+
+        # @param [Array<RequestParams::Base>] params
+        def initialize(params)
+          @params = params
+        end
+
+        # @option options [required,Resource] :resource
+        # @option options [required,Array<Mixed>] :args
+        # @return [Hash]
+        def build(options = {})
+          deep_merge(user_params(options), computed_params(options))
+        end
+
+        private
+
+        def user_params(options)
+          args = options[:args] || []
+          args.last.is_a?(Hash) ? args.last : {} 
+        end
+
+        def computed_params(options)
+          params_hash = {}
+          Array(options[:resource]).each do |resource|
+            @params.each do |param|
+              param.apply(params_hash, options.merge(resource: resource))
+            end
+          end
+          params_hash
+        end
+
+        def deep_merge(obj1, obj2)
+          case obj1
+          when Hash then obj1.merge(obj2) { |key, v1, v2| deep_merge(v1, v2) }
+          when Array then obj2 + obj1
+          else obj2
+          end
+        end
+
+      end
+
+      # Base class for all request parameter types.
+      # @see {RequestParams::Identifier}
+      # @see {RequestParams::DataMember}
+      # @see {RequestParams::String}
+      # @see {RequestParams::Integer}
+      class Base
+
+        # @param [String] target
+        def initialize(target)
+          @target = target.to_s
+          @steps = []
+          @target.scan(/\w+|\[\]/) do |step|
+            case step
+            when /\d+/ then @steps += [:array, step.to_i]
+            when '[]' then @steps += [:array, -1]
+            else @steps += [:hash, step.to_sym]
+            end
+          end
+          @steps.shift
+          @final = @steps.pop
+        end
+
+        # @return [String] target
+        attr_reader :target
+
+        # @param [Hash] params
+        # @param [Object] value
+        # @return [Hash] Returns the modified params hash.
+        def apply(params, value)
+          if @final == -1
+            build_context(params) << value
+          else
+            build_context(params)[@final] = value
+          end
+          params
+        end
+
+        private
+
+        def build_context(params)
+          @steps.each_slice(2).inject(params) do |context, (key, type)|
+            entry = type == :array ? [] : {}
+            if key == -1
+              context << entry
+              entry
+            else
+              context[key] ||= entry
+            end
+          end
+        end
+
+      end
+
+      class Identifier < Base
+
+        # @param [String] identifier_name
+        # @param (see Base#initialize)
+        def initialize(identifier_name, target)
+          @identifier_name = identifier_name.to_sym
+          super(target)
+        end
+
+        # @param [Symbol] identifier_name
+        attr_reader :identifier_name
+
+        # @param [Hash] params_hash
+        # @option [requried, Resource] :resource
+        def apply(params_hash, options)
+          value = options[:resource].identifiers[identifier_name]
+          super(params_hash, value)
+        end
+
+        # @api private
+        def self.literal?
+          false
+        end
+
+      end
+
+      class DataMember < Base
+
+        # @param [String] member_name
+        # @param (see Base#initialize)
+        def initialize(member_name, target)
+          @member_name = member_name
+          super(target)
+        end
+
+        # @return [String]
+        attr_reader :member_name
+
+        # @param [Hash] params_hash
+        # @option [requried, Resource] :resource
+        def apply(params_hash, options)
+          value = options[:resource].data[member_name.to_sym]
+          super(params_hash, value)
+        end
+
+        # @api private
+        def self.literal?
+          false
+        end
+
+      end
+
+      class String < Base
+
+        # @param [String] value
+        # @param (see Base#initialize)
+        def initialize(value, target)
+          @value = value
+          super(target)
+        end
+
+        # @return [String]
+        attr_reader :value
+
+        # @param [Hash] params_hash
+        def apply(params_hash, options = {})
+          super(params_hash, value)
+        end
+
+        # @api private
+        def self.literal?
+          true
+        end
+
+      end
+
+      class Integer < Base
+
+        # @param [String] value
+        # @param (see Base#initialize)
+        def initialize(value, target)
+          @value = value.to_i
+          super(target)
+        end
+
+        # @return [Integer]
+        attr_reader :value
+
+        # @param [Hash] params_hash
+        def apply(params_hash, options = {})
+          super(params_hash, value)
+        end
+
+        # @api private
+        def self.literal?
+          true
+        end
+
+      end
+
+      class Boolean < Base
+
+        # @param [String<'true'>,String<'false'>] value
+        # @param (see Base#initialize)
+        def initialize(value, target)
+          @value = (value == 'true')
+          super(target)
+        end
+
+        # @return [Integer]
+        attr_reader :value
+
+        # @param [Hash] params_hash
+        def apply(params_hash, options = {})
+          super(params_hash, value)
+        end
+
+        # @api private
+        def self.literal?
+          true
+        end
+
+      end
+    end
+  end
+end